 @@ -1,642 +1,642 @@
-/*	$NetBSD: ofw_subr.c,v 1.49 2021/01/25 12:15:33 jmcneill Exp $	*/
+/*	$NetBSD: ofw_subr.c,v 1.50 2021/01/25 19:59:49 mrg Exp $	*/
 /*
  * Copyright 1998
  * Digital Equipment Corporation. All rights reserved.
+ *
  * This software is furnished under license and may be used and
  * copied only in accordance with the following terms and conditions.
  * Subject to these conditions, you may download, copy, install,
  * use, modify and distribute this software in source and/or binary
  * form. No title or ownership is transferred hereby.
+ *
  * 1) Any source code used, modified or distributed must reproduce
  *    and retain this copyright notice and list of conditions as
  *    they appear in the source file.
+ *
  * 2) No right is granted to use any trade name, trademark, or logo of
  *    Digital Equipment Corporation. Neither the "Digital Equipment
  *    Corporation" name nor any trademark or logo of Digital Equipment
  *    Corporation may be used to endorse or promote products derived
  *    from this software without the prior written permission of
  *    Digital Equipment Corporation.
+ *
  * 3) This software is provided "AS-IS" and any express or implied
  *    warranties, including but not limited to, any implied warranties
  *    of merchantability, fitness for a particular purpose, or
  *    non-infringement are disclaimed. In no event shall DIGITAL be
  *    liable for any damages whatsoever, and in particular, DIGITAL
  *    shall not be liable for special, indirect, consequential, or
  *    incidental damages or damages for lost profits, loss of
  *    revenue or loss of use, whether such damages arise in contract,
  *    negligence, tort, under statute, in equity, at law or otherwise,
  *    even if advised of the possibility of such damage.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ofw_subr.c,v 1.49 2021/01/25 12:15:33 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ofw_subr.c,v 1.50 2021/01/25 19:59:49 mrg Exp $");
 #include <sys/param.h>
 #include <sys/device.h>
 #include <sys/kmem.h>
 #include <sys/systm.h>
 #include <dev/ofw/openfirm.h>
 #include <dev/i2c/i2cvar.h>
 #define	OFW_MAX_STACK_BUF_SIZE	256
 #define	OFW_PATH_BUF_SIZE	512
 /*
  * int of_decode_int(p)
+ *
  * This routine converts OFW encoded-int datums
  * into the integer format of the host machine.
+ *
  * It is primarily used to convert integer properties
  * returned by the OF_getprop routine.
+ *
  * Arguments:
  *	p		pointer to unsigned char array which is an
  *			OFW-encoded integer.
+ *
  * Return Value:
  *	Decoded integer value of argument p.
+ *
  * Side Effects:
  *	None.
  */
 int
 of_decode_int(const unsigned char *p)
+{
 	unsigned int i = *p++ << 8;
 	i = (i + *p++) << 8;
 	i = (i + *p++) << 8;
 	return (i + *p);
+}
 /*
  * int of_compatible(phandle, strings)
+ *
  * This routine checks an OFW node's "compatible" entry to see if
  * it matches any of the provided strings.
+ *
  * It should be used when determining whether a driver can drive
  * a particular device.
+ *
  * Arguments:
  *	phandle		OFW phandle of device to be checked for
  *			compatibility.
  *	strings		Array of containing expected "compatibility"
  *			property values, presence of any of which
  *			indicates compatibility.
+ *
  * Return Value:
  *	-1 if none of the strings are found in phandle's "compatibility"
  *	property, or the reverse index of the matching string in the
  *	phandle's "compatibility" property.
+ *
  * Side Effects:
  *	None.
  */
 int
 of_compatible(int phandle, const char * const *strings)
+{
 	char *prop, propbuf[OFW_MAX_STACK_BUF_SIZE];
 	const char *cp;
 	int proplen, match, rv = -1;
 	proplen = OF_getproplen(phandle, "compatible");
 	if (proplen <= 0) {
 		return -1;
+	}
 	prop = kmem_tmpbuf_alloc(proplen, propbuf, sizeof(propbuf), KM_SLEEP);
 	if (OF_getprop(phandle, "compatible", prop, proplen) != proplen) {
 		goto out;
+	}
 	for (; (cp = *strings) != NULL; strings++) {
 		if ((match = strlist_match(prop, proplen, cp)) != 0) {
 			rv = match - 1;
 			break;
+		}
+	}
  out:
 	kmem_tmpbuf_free(prop, proplen, propbuf);
 	return rv;
+}
 /*
  * int of_match_compatible(phandle, strings)
+ *
  * This routine checks an OFW node's "compatible" entry to see if
  * it matches any of the provided strings.
+ *
  * It should be used when determining whether a driver can drive
  * a particular device.
+ *
  * Arguments:
  *	phandle		OFW phandle of device to be checked for
  *			compatibility.
  *	strings		Array of containing expected "compatibility"
  *			property values, presence of any of which
  *			indicates compatibility.
+ *
  * Return Value:
  *	0 if none of the strings are found in phandle's "compatibility"
  *	property, or a positive number based on the reverse index of the
  *	matching string in the phandle's "compatibility" property, plus 1.
+ *
  * Side Effects:
  *	None.
  */
 int
 of_match_compatible(int phandle, const char * const *strings)
+{
 	return of_compatible(phandle, strings) + 1;
+}
 /*
  * int of_match_compat_data(phandle, compat_data)
+ *
  * This routine searches an array of compat_data structures for a
  * matching "compatible" entry matching the supplied OFW node.
+ *
  * It should be used when determining whether a driver can drive
  * a particular device.
+ *
  * Arguments:
  *	phandle		OFW phandle of device to be checked for
  *			compatibility.
  *	compat_data	Array of possible compat entry strings and
  *			associated metadata. The last entry in the
  *			list should have a "compat" of NULL to terminate
  *			the list.
+ *
  * Return Value:
  *	0 if none of the strings are found in phandle's "compatibility"
  *	property, or a positive number based on the reverse index of the
  *	matching string in the phandle's "compatibility" property, plus 1.
+ *
  * Side Effects:
  *	None.
  */
 int
 of_match_compat_data(int phandle,
     const struct device_compatible_entry *compat_data)
+{
 	char *prop, propbuf[OFW_MAX_STACK_BUF_SIZE];
 	int proplen, match = 0;
 	proplen = OF_getproplen(phandle, "compatible");
 	if (proplen <= 0) {
 		return 0;
+	}
 	prop = kmem_tmpbuf_alloc(proplen, propbuf, sizeof(propbuf), KM_SLEEP);
 	if (OF_getprop(phandle, "compatible", prop, proplen) != proplen) {
 		goto out;
+	}
 	match = device_compatible_match_strlist(prop, proplen, compat_data);
  out:
 	kmem_tmpbuf_free(prop, proplen, propbuf);
 	return match;
+}
 /*
  * const struct device_compatible_entry *of_search_compatible(phandle,
  *							      compat_data)
+ *
  * This routine searches an array of compat_data structures for a
  * matching "compatible" entry matching the supplied OFW node.
+ *
  * Arguments:
  *	phandle		OFW phandle of device to be checked for
  *			compatibility.
  *	compat_data	Array of possible compat entry strings and
  *			associated metadata. The last entry in the
  *			list should have a "compat" of NULL to terminate
  *			the list.
+ *
  * Return Value:
  *	The first matching compat_data entry in the array. If no matches
  *	are found, NULL is returned.
+ *
  * Side Effects:
  *	None.
  */
 const struct device_compatible_entry *
 of_search_compatible(int phandle,
     const struct device_compatible_entry *compat_data)
+{
 	char *prop, propbuf[OFW_MAX_STACK_BUF_SIZE];
 	const struct device_compatible_entry *match = NULL;
 	int proplen;
 	proplen = OF_getproplen(phandle, "compatible");
 	if (proplen <= 0) {
 		return 0;
+	}
 	prop = kmem_tmpbuf_alloc(proplen, propbuf, sizeof(propbuf), KM_SLEEP);
 	if (OF_getprop(phandle, "compatible", prop, proplen) != proplen) {
 		goto out;
+	}
 	match = device_compatible_lookup_strlist(prop, proplen, compat_data);
  out:
 	kmem_tmpbuf_free(prop, proplen, propbuf);
 	return match;
+}
 /*
  * int of_packagename(phandle, buf, bufsize)
+ *
  * This routine places the last component of an OFW node's name
  * into a user-provided buffer.
+ *
  * It can be used during autoconfiguration to make printing of
  * device names more informative.
+ *
  * Arguments:
  *	phandle		OFW phandle of device whose name name is
  *			desired.
  *	buf		Buffer to contain device name, provided by
  *			caller.  (For now, must be at least 4
  *			bytes long.)
  *	bufsize		Length of buffer referenced by 'buf', in
  *			bytes.
+ *
  * Return Value:
  *	-1 if the device path name could not be obtained or would
  *	not fit in the allocated temporary buffer, or zero otherwise
  *	(meaning that the leaf node name was successfully extracted).
+ *
  * Side Effects:
  *	If the leaf node name was successfully extracted, 'buf' is
  *	filled in with at most 'bufsize' bytes of the leaf node
  *	name.  If the leaf node was not successfully extracted, a
  *	somewhat meaningful string is placed in the buffer.  In
  *	either case, the contents of 'buf' will be NUL-terminated.
  */
 int
 of_packagename(int phandle, char *buf, int bufsize)
+{
 	char *pbuf;
 	const char *lastslash;
 	int l, rv;
 	pbuf = kmem_alloc(OFW_PATH_BUF_SIZE, KM_SLEEP);
 	l = OF_package_to_path(phandle, pbuf, OFW_PATH_BUF_SIZE);
 	/* check that we could get the name, and that it's not too long. */
 	if (l < 0 ||
 	    (l == OFW_PATH_BUF_SIZE && pbuf[OFW_PATH_BUF_SIZE - 1] != '\0')) {
 		if (bufsize >= 25)
 			snprintf(buf, bufsize, "??? (phandle 0x%x)", phandle);
 		else if (bufsize >= 4)
 			strlcpy(buf, "???", bufsize);
 		else
 			panic("of_packagename: bufsize = %d is silly",
 			    bufsize);
 		rv = -1;
 	} else {
 		pbuf[l] = '\0';
 		lastslash = strrchr(pbuf, '/');
 		strlcpy(buf, (lastslash == NULL) ? pbuf : (lastslash + 1),
 		    bufsize);
 		rv = 0;
+	}
 	kmem_free(pbuf, OFW_PATH_BUF_SIZE);
 	return (rv);
+}
 /*
  * Find the first child of a given node that matches name. Does not recurse.
  */
 int
 of_find_firstchild_byname(int node, const char *name)
+{
 	char namex[32];
 	int nn;
 	for (nn = OF_child(node); nn; nn = OF_peer(nn)) {
 		memset(namex, 0, sizeof(namex));
 		if (OF_getprop(nn, "name", namex, sizeof(namex)) == -1)
 			continue;
 		if (strcmp(name, namex) == 0)
 			return nn;
+	}
 	return -1;
+}
 /*
  * Find a child node that is compatible with str. Recurses, starting at node.
  */
 int
 of_find_bycompat(int node, const char *str)
+{
 	const char * compatible[] = { str, NULL };
 	int child, ret;
 	for (child = OF_child(node); child; child = OF_peer(child)) {
 		if (of_match_compatible(child, compatible) != 0)
 			return child;
 		ret = of_find_bycompat(child, str);
 		if (ret != -1)
 			return ret;
+	}
 	return -1;
+}
 /*
  * Find a give node by name.  Recurses, and seems to walk upwards too.
  */
 int
 of_getnode_byname(int start, const char *target)
+{
 	int node, next;
 	char name[64];
 	if (start == 0)
 		start = OF_peer(0);
 	for (node = start; node; node = next) {
 		memset(name, 0, sizeof name);
 		OF_getprop(node, "name", name, sizeof name - 1);
 		if (strcmp(name, target) == 0)
 			break;
 		if ((next = OF_child(node)) != 0)
 			continue;
 		while (node) {
 			if ((next = OF_peer(node)) != 0)
 				break;
 			node = OF_parent(node);
+		}
+	}
 	/* XXX is this correct? */
 	return node;
+}
 /*
  * Create a uint32_t integer property from an OFW node property.
  */
-boolean_t
+bool
 of_to_uint32_prop(prop_dictionary_t dict, int node, const char *ofname,
     const char *propname)
+{
 	uint32_t prop;
 	if (OF_getprop(node, ofname, &prop, sizeof(prop)) != sizeof(prop))
 		return FALSE;
 	return(prop_dictionary_set_uint32(dict, propname, prop));
+}
 /*
  * Create a data property from an OFW node property.  Max size of 256bytes.
  */
-boolean_t
+bool
 of_to_dataprop(prop_dictionary_t dict, int node, const char *ofname,
     const char *propname)
+{
 	int len;
 	uint8_t prop[256];
 	len = OF_getprop(node, ofname, prop, 256);
 	if (len < 1)
 		return FALSE;
 	return prop_dictionary_set_data(dict, propname, prop, len);
+}
 /*
  * look at output-device, see if there's a Sun-typical video mode specifier as
  * in screen:r1024x768x60 attached. If found copy it into *buffer, otherwise
  * return NULL
  */
 char *
 of_get_mode_string(char *buffer, int len)
+{
 	int options;
 	char *pos, output_device[256];
 	/*
 	 * finally, let's see if there's a video mode specified in
 	 * output-device and pass it on so there's at least some way
 	 * to program video modes
 	 */
 	options = OF_finddevice("/options");
 	if ((options == 0) || (options == -1))
 		return NULL;
 	if (OF_getprop(options, "output-device", output_device, 256) == 0)
 		return NULL;
 	/* find the mode string if there is one */
 	pos = strstr(output_device, ":r");
 	if (pos == NULL)
 		return NULL;
 	strncpy(buffer, pos + 2, len);
 	return buffer;
+}
 /*
  * Iterate over the subtree of a i2c controller node.
  * Add all sub-devices into an array as part of the controller's
  * device properties.
  * This is used by the i2c bus attach code to do direct configuration.
  */
 void
 of_enter_i2c_devs(prop_dictionary_t props, int ofnode, size_t cell_size,
     int addr_shift)
+{
 	int node, len;
 	char name[32];
 	uint64_t reg64;
 	uint32_t reg32;
 	uint64_t addr;
 	prop_array_t array = NULL;
 	prop_dictionary_t dev;
 	for (node = OF_child(ofnode); node; node = OF_peer(node)) {
 		if (OF_getprop(node, "name", name, sizeof(name)) <= 0)
 			continue;
 		len = OF_getproplen(node, "reg");
 		addr = 0;
 		if (cell_size == 8 && len >= sizeof(reg64)) {
 			if (OF_getprop(node, "reg", &reg64, sizeof(reg64))
 			    < sizeof(reg64))
 				continue;
 			addr = be64toh(reg64);
 			/*
 			 * The i2c bus number (0 or 1) is encoded in bit 33
 			 * of the register, but we encode it in bit 8 of
 			 * i2c_addr_t.
 			 */
 			if (addr & 0x100000000)
 				addr = (addr & 0xff) | 0x100;
 		} else if (cell_size == 4 && len >= sizeof(reg32)) {
 			if (OF_getprop(node, "reg", &reg32, sizeof(reg32))
 			    < sizeof(reg32))
 				continue;
 			addr = be32toh(reg32);
 		} else {
 			continue;
+		}
 		addr >>= addr_shift;
 		if (addr == 0) continue;
 		if (array == NULL)
 			array = prop_array_create();
 		dev = prop_dictionary_create();
 		prop_dictionary_set_string(dev, "name", name);
 		prop_dictionary_set_uint32(dev, "addr", addr);
 		prop_dictionary_set_uint64(dev, "cookie", node);
 		prop_dictionary_set_uint32(dev, "cookietype", I2C_COOKIE_OF);
 		of_to_dataprop(dev, node, "compatible", "compatible");
 		prop_array_add(array, dev);
 		prop_object_release(dev);
+	}
 	if (array != NULL) {
 		prop_dictionary_set(props, "i2c-child-devices", array);
 		prop_object_release(array);
+	}
+}
 void
 of_enter_spi_devs(prop_dictionary_t props, int ofnode, size_t cell_size)
+{
 	int node, len;
 	char name[32];
 	uint64_t reg64;
 	uint32_t reg32;
 	uint32_t slave;
 	u_int32_t maxfreq;
 	prop_array_t array = NULL;
 	prop_dictionary_t dev;
 	int mode;
 	for (node = OF_child(ofnode); node; node = OF_peer(node)) {
 		if (OF_getprop(node, "name", name, sizeof(name)) <= 0)
 			continue;
 		len = OF_getproplen(node, "reg");
 		slave = 0;
 		if (cell_size == 8 && len >= sizeof(reg64)) {
 			if (OF_getprop(node, "reg", &reg64, sizeof(reg64))
 			    < sizeof(reg64))
 				continue;
 			slave = be64toh(reg64);
 		} else if (cell_size == 4 && len >= sizeof(reg32)) {
 			if (OF_getprop(node, "reg", &reg32, sizeof(reg32))
 			    < sizeof(reg32))
 				continue;
 			slave = be32toh(reg32);
 		} else {
 			continue;
+		}
 		if (of_getprop_uint32(node, "spi-max-frequency", &maxfreq)) {
 			maxfreq = 0;
+		}
 		mode = ((int)of_hasprop(node, "cpol") << 1) | (int)of_hasprop(node, "cpha");
 		if (array == NULL)
 			array = prop_array_create();
 		dev = prop_dictionary_create();
 		prop_dictionary_set_string(dev, "name", name);
 		prop_dictionary_set_uint32(dev, "slave", slave);
 		prop_dictionary_set_uint32(dev, "mode", mode);
 		if (maxfreq > 0)
 			prop_dictionary_set_uint32(dev, "spi-max-frequency", maxfreq);
 		prop_dictionary_set_uint64(dev, "cookie", node);
 		of_to_dataprop(dev, node, "compatible", "compatible");
 		prop_array_add(array, dev);
 		prop_object_release(dev);
+	}
 	if (array != NULL) {
 		prop_dictionary_set(props, "spi-child-devices", array);
 		prop_object_release(array);
+	}
+}
 /*
  * Returns true if the specified property is present.
  */
 bool
 of_hasprop(int node, const char *prop)
+{
 	return OF_getproplen(node, prop) >= 0;
+}
 /*
  * Get the value of a uint32 property, compensating for host byte order.
  * Returns 0 on success, non-zero on failure.
  */
 int
 of_getprop_uint32(int node, const char *prop, uint32_t *val)
+{
 	uint32_t v;
 	int len;
 	len = OF_getprop(node, prop, &v, sizeof(v));
 	if (len != sizeof(v))
 		return -1;
 	*val = be32toh(v);
 	return 0;
+}
 int
 of_getprop_uint32_array(int node, const char *prop, uint32_t *array, int n)
+{
 	uint32_t *v = array;
 	int len;
 	len = OF_getprop(node, prop, array, n * sizeof(*v));
 	if (len < (int)(n * sizeof(*v)))
 		return -1;
 	for (; n > 0; n--) {
 		BE32TOH(*v);
 		v++;
+	}
 	return 0;
+}
 /*
  * Get the value of a uint64 property, compensating for host byte order.
  * Returns 0 on success, non-zero on failure.
  */
 int
 of_getprop_uint64(int node, const char *prop, uint64_t *val)
+{
 	uint64_t v;
 	int len;
 	len = OF_getprop(node, prop, &v, sizeof(v));
 	if (len != sizeof(v))
 		return -1;
 	*val = be64toh(v);
 	return 0;
+}

 @@ -1,932 +1,932 @@
 /******************************************************************************
   Copyright (c) 2001-2017, Intel Corporation
   All rights reserved.
   Redistribution and use in source and binary forms, with or without
   modification, are permitted provided that the following conditions are met:
 . Redistributions of source code must retain the above copyright notice,
       this list of conditions and the following disclaimer.
 . Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.
 . Neither the name of the Intel Corporation nor the names of its
       contributors may be used to endorse or promote products derived from
       this software without specific prior written permission.
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "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 COPYRIGHT OWNER OR CONTRIBUTORS 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.
 ******************************************************************************/
 /*$FreeBSD: head/sys/dev/ixgbe/if_sriov.c 327031 2017-12-20 18:15:06Z erj $*/
 #include "ixgbe.h"
 #include "ixgbe_sriov.h"
 #ifdef PCI_IOV
 MALLOC_DEFINE(M_IXGBE_SRIOV, "ix_sriov", "ix SR-IOV allocations");
 /************************************************************************
  * ixgbe_pci_iov_detach
  ************************************************************************/
 int
 ixgbe_pci_iov_detach(device_t dev)
+{
 	return pci_iov_detach(dev);
+}
 /************************************************************************
  * ixgbe_define_iov_schemas
  ************************************************************************/
 void
 ixgbe_define_iov_schemas(device_t dev, int *error)
+{
 	nvlist_t *pf_schema, *vf_schema;
 	pf_schema = pci_iov_schema_alloc_node();
 	vf_schema = pci_iov_schema_alloc_node();
 	pci_iov_schema_add_unicast_mac(vf_schema, "mac-addr", 0, NULL);
 	pci_iov_schema_add_bool(vf_schema, "mac-anti-spoof",
 	    IOV_SCHEMA_HASDEFAULT, TRUE);
 	pci_iov_schema_add_bool(vf_schema, "allow-set-mac",
 	    IOV_SCHEMA_HASDEFAULT, FALSE);
 	pci_iov_schema_add_bool(vf_schema, "allow-promisc",
 	    IOV_SCHEMA_HASDEFAULT, FALSE);
 	*error = pci_iov_attach(dev, pf_schema, vf_schema);
 	if (*error != 0) {
 		device_printf(dev,
 		    "Error %d setting up SR-IOV\n", *error);
+	}
 } /* ixgbe_define_iov_schemas */
 /************************************************************************
  * ixgbe_align_all_queue_indices
  ************************************************************************/
 inline void
 ixgbe_align_all_queue_indices(struct adapter *adapter)
+{
 	int i;
 	int index;
 	for (i = 0; i < adapter->num_queues; i++) {
 		index = ixgbe_vf_que_index(adapter->iov_mode, adapter->pool, i);
 		adapter->rx_rings[i].me = index;
 		adapter->tx_rings[i].me = index;
+	}
+}
 /* Support functions for SR-IOV/VF management */
 static inline void
 ixgbe_send_vf_msg(struct adapter *adapter, struct ixgbe_vf *vf, u32 msg)
+{
 	if (vf->flags & IXGBE_VF_CTS)
 		msg |= IXGBE_VT_MSGTYPE_CTS;
 	adapter->hw.mbx.ops.write(&adapter->hw, &msg, 1, vf->pool);
+}
 static inline void
 ixgbe_send_vf_ack(struct adapter *adapter, struct ixgbe_vf *vf, u32 msg)
+{
 	msg &= IXGBE_VT_MSG_MASK;
 	ixgbe_send_vf_msg(adapter, vf, msg | IXGBE_VT_MSGTYPE_ACK);
+}
 static inline void
 ixgbe_send_vf_nack(struct adapter *adapter, struct ixgbe_vf *vf, u32 msg)
+{
 	msg &= IXGBE_VT_MSG_MASK;
 	ixgbe_send_vf_msg(adapter, vf, msg | IXGBE_VT_MSGTYPE_NACK);
+}
 static inline void
 ixgbe_process_vf_ack(struct adapter *adapter, struct ixgbe_vf *vf)
+{
 	if (!(vf->flags & IXGBE_VF_CTS))
 		ixgbe_send_vf_nack(adapter, vf, 0);
+}
-static inline boolean_t
+static inline bool
 ixgbe_vf_mac_changed(struct ixgbe_vf *vf, const uint8_t *mac)
+{
 	return (bcmp(mac, vf->ether_addr, ETHER_ADDR_LEN) != 0);
+}
 static inline int
 ixgbe_vf_queues(int mode)
+{
 	switch (mode) {
 	case IXGBE_64_VM:
 		return (2);
 	case IXGBE_32_VM:
 		return (4);
 	case IXGBE_NO_VM:
 	default:
 		return (0);
+	}
+}
 inline int
 ixgbe_vf_que_index(int mode, int vfnum, int num)
+{
 	return ((vfnum * ixgbe_vf_queues(mode)) + num);
+}
 static inline void
 ixgbe_update_max_frame(struct adapter * adapter, int max_frame)
+{
 	if (adapter->max_frame_size < max_frame)
 		adapter->max_frame_size = max_frame;
+}
 inline u32
 ixgbe_get_mrqc(int iov_mode)
+{
 	u32 mrqc;
 	switch (iov_mode) {
 	case IXGBE_64_VM:
 		mrqc = IXGBE_MRQC_VMDQRSS64EN;
 		break;
 	case IXGBE_32_VM:
 		mrqc = IXGBE_MRQC_VMDQRSS32EN;
 		break;
 	case IXGBE_NO_VM:
 		mrqc = 0;
 		break;
 	default:
 		panic("Unexpected SR-IOV mode %d", iov_mode);
+	}
 	return mrqc;
+}
 inline u32
 ixgbe_get_mtqc(int iov_mode)
+{
 	uint32_t mtqc;
 	switch (iov_mode) {
 	case IXGBE_64_VM:
 		mtqc = IXGBE_MTQC_64VF | IXGBE_MTQC_VT_ENA;
 		break;
 	case IXGBE_32_VM:
 		mtqc = IXGBE_MTQC_32VF | IXGBE_MTQC_VT_ENA;
 		break;
 	case IXGBE_NO_VM:
 		mtqc = IXGBE_MTQC_64Q_1PB;
 		break;
 	default:
 		panic("Unexpected SR-IOV mode %d", iov_mode);
+	}
 	return mtqc;
+}
 void
 ixgbe_ping_all_vfs(struct adapter *adapter)
+{
 	struct ixgbe_vf *vf;
 	for (int i = 0; i < adapter->num_vfs; i++) {
 		vf = &adapter->vfs[i];
 		if (vf->flags & IXGBE_VF_ACTIVE)
 			ixgbe_send_vf_msg(adapter, vf, IXGBE_PF_CONTROL_MSG);
+	}
 } /* ixgbe_ping_all_vfs */
 static void
 ixgbe_vf_set_default_vlan(struct adapter *adapter, struct ixgbe_vf *vf,
                           uint16_t tag)
+{
 	struct ixgbe_hw *hw;
 	uint32_t vmolr, vmvir;
 	hw = &adapter->hw;
 	vf->vlan_tag = tag;
 	vmolr = IXGBE_READ_REG(hw, IXGBE_VMOLR(vf->pool));
 	/* Do not receive packets that pass inexact filters. */
 	vmolr &= ~(IXGBE_VMOLR_ROMPE | IXGBE_VMOLR_ROPE);
 	/* Disable Multicast Promicuous Mode. */
 	vmolr &= ~IXGBE_VMOLR_MPE;
 	/* Accept broadcasts. */
 	vmolr |= IXGBE_VMOLR_BAM;
 	if (tag == 0) {
 		/* Accept non-vlan tagged traffic. */
 		vmolr |= IXGBE_VMOLR_AUPE;
 		/* Allow VM to tag outgoing traffic; no default tag. */
 		vmvir = 0;
 	} else {
 		/* Require vlan-tagged traffic. */
 		vmolr &= ~IXGBE_VMOLR_AUPE;
 		/* Tag all traffic with provided vlan tag. */
 		vmvir = (tag | IXGBE_VMVIR_VLANA_DEFAULT);
+	}
 	IXGBE_WRITE_REG(hw, IXGBE_VMOLR(vf->pool), vmolr);
 	IXGBE_WRITE_REG(hw, IXGBE_VMVIR(vf->pool), vmvir);
 } /* ixgbe_vf_set_default_vlan */
 static void
 ixgbe_clear_vfmbmem(struct ixgbe_hw *hw, struct ixgbe_vf *vf)
+{
 	uint32_t vf_index = IXGBE_VF_INDEX(vf->pool);
 	uint16_t mbx_size = hw->mbx.size;
 	uint16_t i;
 	IXGBE_CORE_LOCK_ASSERT(adapter);
 	for (i = 0; i < mbx_size; ++i)
 		IXGBE_WRITE_REG_ARRAY(hw, IXGBE_PFMBMEM(vf_index), i, 0x0);
 } /* ixgbe_clear_vfmbmem */
-static boolean_t
+static bool
 ixgbe_vf_frame_size_compatible(struct adapter *adapter, struct ixgbe_vf *vf)
+{
 	/*
 	 * Frame size compatibility between PF and VF is only a problem on
 	 * 82599-based cards.  X540 and later support any combination of jumbo
 	 * frames on PFs and VFs.
 	 */
 	if (adapter->hw.mac.type != ixgbe_mac_82599EB)
 		return (TRUE);
 	switch (vf->api_ver) {
 	case IXGBE_API_VER_1_0:
 	case IXGBE_API_VER_UNKNOWN:
 		/*
 		 * On legacy (1.0 and older) VF versions, we don't support jumbo
 		 * frames on either the PF or the VF.
 		 */
 		if (adapter->max_frame_size > ETHER_MAX_LEN ||
 		    vf->max_frame_size > ETHER_MAX_LEN)
 			return (FALSE);
 		return (TRUE);
 		break;
 	case IXGBE_API_VER_1_1:
 	default:
 		/*
 		 * 1.1 or later VF versions always work if they aren't using
 		 * jumbo frames.
 		 */
 		if (vf->max_frame_size <= ETHER_MAX_LEN)
 			return (TRUE);
 		/*
 		 * Jumbo frames only work with VFs if the PF is also using jumbo
 		 * frames.
 		 */
 		if (adapter->max_frame_size <= ETHER_MAX_LEN)
 			return (TRUE);
 		return (FALSE);
+	}
 } /* ixgbe_vf_frame_size_compatible */
 static void
 ixgbe_process_vf_reset(struct adapter *adapter, struct ixgbe_vf *vf)
+{
 	ixgbe_vf_set_default_vlan(adapter, vf, vf->default_vlan);
 	// XXX clear multicast addresses
 	ixgbe_clear_rar(&adapter->hw, vf->rar_index);
 	ixgbe_clear_vfmbmem(&adapter->hw, vf);
 	ixgbe_toggle_txdctl(&adapter->hw, IXGBE_VF_INDEX(vf->pool));
 	vf->api_ver = IXGBE_API_VER_UNKNOWN;
 } /* ixgbe_process_vf_reset */
 static void
 ixgbe_vf_enable_transmit(struct adapter *adapter, struct ixgbe_vf *vf)
+{
 	struct ixgbe_hw *hw;
 	uint32_t vf_index, vfte;
 	hw = &adapter->hw;
 	vf_index = IXGBE_VF_INDEX(vf->pool);
 	vfte = IXGBE_READ_REG(hw, IXGBE_VFTE(vf_index));
 	vfte |= IXGBE_VF_BIT(vf->pool);
 	IXGBE_WRITE_REG(hw, IXGBE_VFTE(vf_index), vfte);
 } /* ixgbe_vf_enable_transmit */
 static void
 ixgbe_vf_enable_receive(struct adapter *adapter, struct ixgbe_vf *vf)
+{
 	struct ixgbe_hw *hw;
 	uint32_t vf_index, vfre;
 	hw = &adapter->hw;
 	vf_index = IXGBE_VF_INDEX(vf->pool);
 	vfre = IXGBE_READ_REG(hw, IXGBE_VFRE(vf_index));
 	if (ixgbe_vf_frame_size_compatible(adapter, vf))
 		vfre |= IXGBE_VF_BIT(vf->pool);
 	else
 		vfre &= ~IXGBE_VF_BIT(vf->pool);
 	IXGBE_WRITE_REG(hw, IXGBE_VFRE(vf_index), vfre);
 } /* ixgbe_vf_enable_receive */
 static void
 ixgbe_vf_reset_msg(struct adapter *adapter, struct ixgbe_vf *vf, uint32_t *msg)
+{
 	struct ixgbe_hw *hw;
 	uint32_t ack;
 	uint32_t resp[IXGBE_VF_PERMADDR_MSG_LEN];
 	hw = &adapter->hw;
 	ixgbe_process_vf_reset(adapter, vf);
 	if (ixgbe_validate_mac_addr(vf->ether_addr) == 0) {
 		ixgbe_set_rar(&adapter->hw, vf->rar_index, vf->ether_addr,
 		    vf->pool, TRUE);
 		ack = IXGBE_VT_MSGTYPE_ACK;
 	} else
 		ack = IXGBE_VT_MSGTYPE_NACK;
 	ixgbe_vf_enable_transmit(adapter, vf);
 	ixgbe_vf_enable_receive(adapter, vf);
 	vf->flags |= IXGBE_VF_CTS;
 	resp[0] = IXGBE_VF_RESET | ack;
 	bcopy(vf->ether_addr, &resp[1], ETHER_ADDR_LEN);
 	resp[3] = hw->mac.mc_filter_type;
 	hw->mbx.ops.write(hw, resp, IXGBE_VF_PERMADDR_MSG_LEN, vf->pool);
 } /* ixgbe_vf_reset_msg */
 static void
 ixgbe_vf_set_mac(struct adapter *adapter, struct ixgbe_vf *vf, uint32_t *msg)
+{
 	uint8_t *mac;
 	mac = (uint8_t*)&msg[1];
 	/* Check that the VF has permission to change the MAC address. */
 	if (!(vf->flags & IXGBE_VF_CAP_MAC) && ixgbe_vf_mac_changed(vf, mac)) {
 		ixgbe_send_vf_nack(adapter, vf, msg[0]);
 		return;
+	}
 	if (ixgbe_validate_mac_addr(mac) != 0) {
 		ixgbe_send_vf_nack(adapter, vf, msg[0]);
 		return;
+	}
 	bcopy(mac, vf->ether_addr, ETHER_ADDR_LEN);
 	ixgbe_set_rar(&adapter->hw, vf->rar_index, vf->ether_addr, vf->pool,
 	    TRUE);
 	ixgbe_send_vf_ack(adapter, vf, msg[0]);
 } /* ixgbe_vf_set_mac */
 /*
  * VF multicast addresses are set by using the appropriate bit in
  * 1 of 128 32 bit addresses (4096 possible).
  */
 static void
 ixgbe_vf_set_mc_addr(struct adapter *adapter, struct ixgbe_vf *vf, u32 *msg)
+{
 	u16	*list = (u16*)&msg[1];
 	int	entries;
 	u32	vmolr, vec_bit, vec_reg, mta_reg;
 	entries = (msg[0] & IXGBE_VT_MSGINFO_MASK) >> IXGBE_VT_MSGINFO_SHIFT;
 	entries = uimin(entries, IXGBE_MAX_VF_MC);
 	vmolr = IXGBE_READ_REG(&adapter->hw, IXGBE_VMOLR(vf->pool));
 	vf->num_mc_hashes = entries;
 	/* Set the appropriate MTA bit */
 	for (int i = 0; i < entries; i++) {
 		vf->mc_hash[i] = list[i];
 		vec_reg = (vf->mc_hash[i] >> 5) & 0x7F;
 		vec_bit = vf->mc_hash[i] & 0x1F;
 		mta_reg = IXGBE_READ_REG(&adapter->hw, IXGBE_MTA(vec_reg));
 		mta_reg |= (1 << vec_bit);
 		IXGBE_WRITE_REG(&adapter->hw, IXGBE_MTA(vec_reg), mta_reg);
+	}
 	vmolr |= IXGBE_VMOLR_ROMPE;
 	IXGBE_WRITE_REG(&adapter->hw, IXGBE_VMOLR(vf->pool), vmolr);
 	ixgbe_send_vf_ack(adapter, vf, msg[0]);
 } /* ixgbe_vf_set_mc_addr */
 static void
 ixgbe_vf_set_vlan(struct adapter *adapter, struct ixgbe_vf *vf, uint32_t *msg)
+{
 	struct ixgbe_hw *hw;
 	int enable;
 	uint16_t tag;
 	hw = &adapter->hw;
 	enable = IXGBE_VT_MSGINFO(msg[0]);
 	tag = msg[1] & IXGBE_VLVF_VLANID_MASK;
 	if (!(vf->flags & IXGBE_VF_CAP_VLAN)) {
 		ixgbe_send_vf_nack(adapter, vf, msg[0]);
 		return;
+	}
 	/* It is illegal to enable vlan tag 0. */
 	if (tag == 0 && enable != 0) {
 		ixgbe_send_vf_nack(adapter, vf, msg[0]);
 		return;
+	}
 	ixgbe_set_vfta(hw, tag, vf->pool, enable, false);
 	ixgbe_send_vf_ack(adapter, vf, msg[0]);
 } /* ixgbe_vf_set_vlan */
 static void
 ixgbe_vf_set_lpe(struct adapter *adapter, struct ixgbe_vf *vf, uint32_t *msg)
+{
 	struct ixgbe_hw *hw;
 	uint32_t vf_max_size, pf_max_size, mhadd;
 	hw = &adapter->hw;
 	vf_max_size = msg[1];
 	if (vf_max_size < ETHER_CRC_LEN) {
 		/* We intentionally ACK invalid LPE requests. */
 		ixgbe_send_vf_ack(adapter, vf, msg[0]);
 		return;
+	}
 	vf_max_size -= ETHER_CRC_LEN;
 	if (vf_max_size > IXGBE_MAX_FRAME_SIZE) {
 		/* We intentionally ACK invalid LPE requests. */
 		ixgbe_send_vf_ack(adapter, vf, msg[0]);
 		return;
+	}
 	vf->max_frame_size = vf_max_size;
 	ixgbe_update_max_frame(adapter, vf->max_frame_size);
 	/*
 	 * We might have to disable reception to this VF if the frame size is
 	 * not compatible with the config on the PF.
 	 */
 	ixgbe_vf_enable_receive(adapter, vf);
 	mhadd = IXGBE_READ_REG(hw, IXGBE_MHADD);
 	pf_max_size = (mhadd & IXGBE_MHADD_MFS_MASK) >> IXGBE_MHADD_MFS_SHIFT;
 	if (pf_max_size < adapter->max_frame_size) {
 		mhadd &= ~IXGBE_MHADD_MFS_MASK;
 		mhadd |= adapter->max_frame_size << IXGBE_MHADD_MFS_SHIFT;
 		IXGBE_WRITE_REG(hw, IXGBE_MHADD, mhadd);
+	}
 	ixgbe_send_vf_ack(adapter, vf, msg[0]);
 } /* ixgbe_vf_set_lpe */
 static void
 ixgbe_vf_set_macvlan(struct adapter *adapter, struct ixgbe_vf *vf,
                      uint32_t *msg)
+{
 	//XXX implement this
 	ixgbe_send_vf_nack(adapter, vf, msg[0]);
 } /* ixgbe_vf_set_macvlan */
 static void
 ixgbe_vf_api_negotiate(struct adapter *adapter, struct ixgbe_vf *vf,
     uint32_t *msg)
+{
 	switch (msg[1]) {
 	case IXGBE_API_VER_1_0:
 	case IXGBE_API_VER_1_1:
 		vf->api_ver = msg[1];
 		ixgbe_send_vf_ack(adapter, vf, msg[0]);
 		break;
 	default:
 		vf->api_ver = IXGBE_API_VER_UNKNOWN;
 		ixgbe_send_vf_nack(adapter, vf, msg[0]);
 		break;
+	}
 } /* ixgbe_vf_api_negotiate */
 static void
 ixgbe_vf_get_queues(struct adapter *adapter, struct ixgbe_vf *vf, uint32_t *msg)
+{
 	struct ixgbe_hw *hw;
 	uint32_t resp[IXGBE_VF_GET_QUEUES_RESP_LEN];
 	int num_queues;
 	hw = &adapter->hw;
 	/* GET_QUEUES is not supported on pre-1.1 APIs. */
 	switch (msg[0]) {
 	case IXGBE_API_VER_1_0:
 	case IXGBE_API_VER_UNKNOWN:
 		ixgbe_send_vf_nack(adapter, vf, msg[0]);
 		return;
+	}
 	resp[0] = IXGBE_VF_GET_QUEUES | IXGBE_VT_MSGTYPE_ACK |
 	    IXGBE_VT_MSGTYPE_CTS;
 	num_queues = ixgbe_vf_queues(adapter->iov_mode);
 	resp[IXGBE_VF_TX_QUEUES] = num_queues;
 	resp[IXGBE_VF_RX_QUEUES] = num_queues;
 	resp[IXGBE_VF_TRANS_VLAN] = (vf->default_vlan != 0);
 	resp[IXGBE_VF_DEF_QUEUE] = 0;
 	hw->mbx.ops.write(hw, resp, IXGBE_VF_GET_QUEUES_RESP_LEN, vf->pool);
 } /* ixgbe_vf_get_queues */
 static void
 ixgbe_process_vf_msg(struct adapter *adapter, struct ixgbe_vf *vf)
+{
 	struct ixgbe_hw *hw;
 	uint32_t msg[IXGBE_VFMAILBOX_SIZE];
 	int error;
 	hw = &adapter->hw;
 	error = hw->mbx.ops.read(hw, msg, IXGBE_VFMAILBOX_SIZE, vf->pool);
 	if (error != 0)
 		return;
 	CTR3(KTR_MALLOC, "%s: received msg %x from %d", adapter->ifp->if_xname,
 	    msg[0], vf->pool);
 	if (msg[0] == IXGBE_VF_RESET) {
 		ixgbe_vf_reset_msg(adapter, vf, msg);
 		return;
+	}
 	if (!(vf->flags & IXGBE_VF_CTS)) {
 		ixgbe_send_vf_nack(adapter, vf, msg[0]);
 		return;
+	}
 	switch (msg[0] & IXGBE_VT_MSG_MASK) {
 	case IXGBE_VF_SET_MAC_ADDR:
 		ixgbe_vf_set_mac(adapter, vf, msg);
 		break;
 	case IXGBE_VF_SET_MULTICAST:
 		ixgbe_vf_set_mc_addr(adapter, vf, msg);
 		break;
 	case IXGBE_VF_SET_VLAN:
 		ixgbe_vf_set_vlan(adapter, vf, msg);
 		break;
 	case IXGBE_VF_SET_LPE:
 		ixgbe_vf_set_lpe(adapter, vf, msg);
 		break;
 	case IXGBE_VF_SET_MACVLAN:
 		ixgbe_vf_set_macvlan(adapter, vf, msg);
 		break;
 	case IXGBE_VF_API_NEGOTIATE:
 		ixgbe_vf_api_negotiate(adapter, vf, msg);
 		break;
 	case IXGBE_VF_GET_QUEUES:
 		ixgbe_vf_get_queues(adapter, vf, msg);
 		break;
 	default:
 		ixgbe_send_vf_nack(adapter, vf, msg[0]);
+	}
 } /* ixgbe_process_vf_msg */
 /* Tasklet for handling VF -> PF mailbox messages */
 void
 ixgbe_handle_mbx(void *context, int pending)
+{
 	struct adapter *adapter = context;
 	struct ixgbe_hw *hw;
 	struct ixgbe_vf *vf;
 	int i;
 	KASSERT(mutex_owned(&adapter->core_mtx));
 	hw = &adapter->hw;
 	for (i = 0; i < adapter->num_vfs; i++) {
 		vf = &adapter->vfs[i];
 		if (vf->flags & IXGBE_VF_ACTIVE) {
 			if (hw->mbx.ops.check_for_rst(hw, vf->pool) == 0)
 				ixgbe_process_vf_reset(adapter, vf);
 			if (hw->mbx.ops.check_for_msg(hw, vf->pool) == 0)
 				ixgbe_process_vf_msg(adapter, vf);
 			if (hw->mbx.ops.check_for_ack(hw, vf->pool) == 0)
 				ixgbe_process_vf_ack(adapter, vf);
+		}
+	}
 } /* ixgbe_handle_mbx */
 int
 ixgbe_init_iov(device_t dev, u16 num_vfs, const nvlist_t *config)
+{
 	struct adapter *adapter;
 	int retval = 0;
 	adapter = device_get_softc(dev);
 	adapter->iov_mode = IXGBE_NO_VM;
 	if (num_vfs == 0) {
 		/* Would we ever get num_vfs = 0? */
 		retval = EINVAL;
 		goto err_init_iov;
+	}
 	/*
 	 * We've got to reserve a VM's worth of queues for the PF,
 	 * thus we go into "64 VF mode" if 32+ VFs are requested.
 	 * With 64 VFs, you can only have two queues per VF.
 	 * With 32 VFs, you can have up to four queues per VF.
 	 */
 	if (num_vfs >= IXGBE_32_VM)
 		adapter->iov_mode = IXGBE_64_VM;
 	else
 		adapter->iov_mode = IXGBE_32_VM;
 	/* Again, reserving 1 VM's worth of queues for the PF */
 	adapter->pool = adapter->iov_mode - 1;
 	if ((num_vfs > adapter->pool) || (num_vfs >= IXGBE_64_VM)) {
 		retval = ENOSPC;
 		goto err_init_iov;
+	}
 	IXGBE_CORE_LOCK(adapter);
 	adapter->vfs = malloc(sizeof(*adapter->vfs) * num_vfs, M_IXGBE_SRIOV,
 	    M_NOWAIT | M_ZERO);
 	if (adapter->vfs == NULL) {
 		retval = ENOMEM;
 		IXGBE_CORE_UNLOCK(adapter);
 		goto err_init_iov;
+	}
 	adapter->num_vfs = num_vfs;
 	/* set the SRIOV flag now as it's needed
 	 * by ixgbe_init_locked() */
 	adapter->feat_en |= IXGBE_FEATURE_SRIOV;
 	adapter->init_locked(adapter);
 	IXGBE_CORE_UNLOCK(adapter);
 	return (retval);
 err_init_iov:
 	adapter->num_vfs = 0;
 	adapter->pool = 0;
 	adapter->iov_mode = IXGBE_NO_VM;
 	return (retval);
 } /* ixgbe_init_iov */
 void
 ixgbe_uninit_iov(device_t dev)
+{
 	struct ixgbe_hw *hw;
 	struct adapter *adapter;
 	uint32_t pf_reg, vf_reg;
 	adapter = device_get_softc(dev);
 	hw = &adapter->hw;
 	IXGBE_CORE_LOCK(adapter);
 	/* Enable rx/tx for the PF and disable it for all VFs. */
 	pf_reg = IXGBE_VF_INDEX(adapter->pool);
 	IXGBE_WRITE_REG(hw, IXGBE_VFRE(pf_reg), IXGBE_VF_BIT(adapter->pool));
 	IXGBE_WRITE_REG(hw, IXGBE_VFTE(pf_reg), IXGBE_VF_BIT(adapter->pool));
 	if (pf_reg == 0)
 		vf_reg = 1;
 	else
 		vf_reg = 0;
 	IXGBE_WRITE_REG(hw, IXGBE_VFRE(vf_reg), 0);
 	IXGBE_WRITE_REG(hw, IXGBE_VFTE(vf_reg), 0);
 	IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, 0);
 	free(adapter->vfs, M_IXGBE_SRIOV);
 	adapter->vfs = NULL;
 	adapter->num_vfs = 0;
 	adapter->feat_en &= ~IXGBE_FEATURE_SRIOV;
 	IXGBE_CORE_UNLOCK(adapter);
 } /* ixgbe_uninit_iov */
 static void
 ixgbe_init_vf(struct adapter *adapter, struct ixgbe_vf *vf)
+{
 	struct ixgbe_hw *hw;
 	uint32_t vf_index, pfmbimr;
 	IXGBE_CORE_LOCK_ASSERT(adapter);
 	hw = &adapter->hw;
 	if (!(vf->flags & IXGBE_VF_ACTIVE))
 		return;
 	vf_index = IXGBE_VF_INDEX(vf->pool);
 	pfmbimr = IXGBE_READ_REG(hw, IXGBE_PFMBIMR(vf_index));
 	pfmbimr |= IXGBE_VF_BIT(vf->pool);
 	IXGBE_WRITE_REG(hw, IXGBE_PFMBIMR(vf_index), pfmbimr);
 	ixgbe_vf_set_default_vlan(adapter, vf, vf->vlan_tag);
 	// XXX multicast addresses
 	if (ixgbe_validate_mac_addr(vf->ether_addr) == 0) {
 		ixgbe_set_rar(&adapter->hw, vf->rar_index,
 		    vf->ether_addr, vf->pool, TRUE);
+	}
 	ixgbe_vf_enable_transmit(adapter, vf);
 	ixgbe_vf_enable_receive(adapter, vf);
 	ixgbe_send_vf_msg(adapter, vf, IXGBE_PF_CONTROL_MSG);
 } /* ixgbe_init_vf */
 void
 ixgbe_initialize_iov(struct adapter *adapter)
+{
 	struct ixgbe_hw *hw = &adapter->hw;
 	uint32_t mrqc, mtqc, vt_ctl, vf_reg, gcr_ext, gpie;
 	int i;
 	if (adapter->iov_mode == IXGBE_NO_VM)
 		return;
 	IXGBE_CORE_LOCK_ASSERT(adapter);
 	/* RMW appropriate registers based on IOV mode */
 	/* Read... */
 	mrqc    = IXGBE_READ_REG(hw, IXGBE_MRQC);
 	gcr_ext = IXGBE_READ_REG(hw, IXGBE_GCR_EXT);
 	gpie    = IXGBE_READ_REG(hw, IXGBE_GPIE);
 	/* Modify... */
 	mrqc    &= ~IXGBE_MRQC_MRQE_MASK;
 	mtqc     =  IXGBE_MTQC_VT_ENA;      /* No initial MTQC read needed */
 	gcr_ext |=  IXGBE_GCR_EXT_MSIX_EN;
 	gcr_ext &= ~IXGBE_GCR_EXT_VT_MODE_MASK;
 	gpie    &= ~IXGBE_GPIE_VTMODE_MASK;
 	switch (adapter->iov_mode) {
 	case IXGBE_64_VM:
 		mrqc    |= IXGBE_MRQC_VMDQRSS64EN;
 		mtqc    |= IXGBE_MTQC_64VF;
 		gcr_ext |= IXGBE_GCR_EXT_VT_MODE_64;
 		gpie    |= IXGBE_GPIE_VTMODE_64;
 		break;
 	case IXGBE_32_VM:
 		mrqc    |= IXGBE_MRQC_VMDQRSS32EN;
 		mtqc    |= IXGBE_MTQC_32VF;
 		gcr_ext |= IXGBE_GCR_EXT_VT_MODE_32;
 		gpie    |= IXGBE_GPIE_VTMODE_32;
 		break;
 	default:
 		panic("Unexpected SR-IOV mode %d", adapter->iov_mode);
+	}
 	/* Write... */
 	IXGBE_WRITE_REG(hw, IXGBE_MRQC, mrqc);
 	IXGBE_WRITE_REG(hw, IXGBE_MTQC, mtqc);
 	IXGBE_WRITE_REG(hw, IXGBE_GCR_EXT, gcr_ext);
 	IXGBE_WRITE_REG(hw, IXGBE_GPIE, gpie);
 	/* Enable rx/tx for the PF. */
 	vf_reg = IXGBE_VF_INDEX(adapter->pool);
 	IXGBE_WRITE_REG(hw, IXGBE_VFRE(vf_reg), IXGBE_VF_BIT(adapter->pool));
 	IXGBE_WRITE_REG(hw, IXGBE_VFTE(vf_reg), IXGBE_VF_BIT(adapter->pool));
 	/* Allow VM-to-VM communication. */
 	IXGBE_WRITE_REG(hw, IXGBE_PFDTXGSWC, IXGBE_PFDTXGSWC_VT_LBEN);
 	vt_ctl = IXGBE_VT_CTL_VT_ENABLE | IXGBE_VT_CTL_REPLEN;
 	vt_ctl |= (adapter->pool << IXGBE_VT_CTL_POOL_SHIFT);
 	IXGBE_WRITE_REG(hw, IXGBE_VT_CTL, vt_ctl);
 	for (i = 0; i < adapter->num_vfs; i++)
 		ixgbe_init_vf(adapter, &adapter->vfs[i]);
 } /* ixgbe_initialize_iov */
 /* Check the max frame setting of all active VF's */
 void
 ixgbe_recalculate_max_frame(struct adapter *adapter)
+{
 	struct ixgbe_vf *vf;
 	IXGBE_CORE_LOCK_ASSERT(adapter);
 	for (int i = 0; i < adapter->num_vfs; i++) {
 		vf = &adapter->vfs[i];
 		if (vf->flags & IXGBE_VF_ACTIVE)
 			ixgbe_update_max_frame(adapter, vf->max_frame_size);
+	}
 } /* ixgbe_recalculate_max_frame */
 int
 ixgbe_add_vf(device_t dev, u16 vfnum, const nvlist_t *config)
+{
 	struct adapter *adapter;
 	struct ixgbe_vf *vf;
 	const void *mac;
 	adapter = device_get_softc(dev);
 	KASSERT(vfnum < adapter->num_vfs, ("VF index %d is out of range %d",
 	    vfnum, adapter->num_vfs));
 	IXGBE_CORE_LOCK(adapter);
 	vf = &adapter->vfs[vfnum];
 	vf->pool= vfnum;
 	/* RAR[0] is used by the PF so use vfnum + 1 for VF RAR. */
 	vf->rar_index = vfnum + 1;
 	vf->default_vlan = 0;
 	vf->max_frame_size = ETHER_MAX_LEN;
 	ixgbe_update_max_frame(adapter, vf->max_frame_size);
 	if (nvlist_exists_binary(config, "mac-addr")) {
 		mac = nvlist_get_binary(config, "mac-addr", NULL);
 		bcopy(mac, vf->ether_addr, ETHER_ADDR_LEN);
 		if (nvlist_get_bool(config, "allow-set-mac"))
 			vf->flags |= IXGBE_VF_CAP_MAC;
 	} else
 		/*
 		 * If the administrator has not specified a MAC address then
 		 * we must allow the VF to choose one.
 		 */
 		vf->flags |= IXGBE_VF_CAP_MAC;
 	vf->flags |= IXGBE_VF_ACTIVE;
 	ixgbe_init_vf(adapter, vf);
 	IXGBE_CORE_UNLOCK(adapter);
 	return (0);
 } /* ixgbe_add_vf */
 #else
 void
 ixgbe_handle_mbx(void *context, int pending)
+{
 	UNREFERENCED_2PARAMETER(context, pending);
 } /* ixgbe_handle_mbx */
 inline int
 ixgbe_vf_que_index(int mode, int vfnum, int num)
+{
 	UNREFERENCED_2PARAMETER(mode, vfnum);
 	return num;
 } /* ixgbe_vf_que_index */
 #endif

 @@ -1,135 +1,133 @@
-/*	$NetBSD: openfirm.h,v 1.41 2021/01/18 02:35:49 thorpej Exp $	*/
+/*	$NetBSD: openfirm.h,v 1.42 2021/01/25 19:59:49 mrg Exp $	*/
 /*
  * Copyright (C) 1995, 1996 Wolfgang Solfrank.
  * Copyright (C) 1995, 1996 TooLs GmbH.
  * 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
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by TooLs GmbH.
  * 4. The name of TooLs GmbH may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``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 TOOLS GMBH 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.
  */
 #ifndef _OPENFIRM_H_
 #define _OPENFIRM_H_
 #include <prop/proplib.h>
 /*
  * Prototypes for OpenFirmware Interface Routines
  */
 /*
  * Machine-independent OpenFirmware-related structures.
  * XXX THESE DO NOT BELONG HERE.
  */
 /*
  * Generic OpenFirmware probe argument.
  * This is how all probe structures must start
  * in order to support generic OpenFirmware device drivers.
  */
 struct ofbus_attach_args {
 	const char	*oba_busname;
 	char		oba_ofname[64];
 	int		oba_phandle;
 	/*
 	 * Special unit field for disk devices.
 	 * This is a KLUDGE to work around the fact that OpenFirmware
 	 * doesn't probe the scsi bus completely.
 	 * YES, I THINK THIS IS A BUG IN THE OPENFIRMWARE DEFINITION!!!	XXX
 	 * See also ofdisk.c.
 	 */
 	int		oba_unit;
 };
 /*
  * Functions and variables provided by machine-dependent code.
  */
 extern char *OF_buf;
 void	OF_boot(const char *) __dead;
 int	OF_call_method(const char *, int, int, int, ...);
 int	OF_call_method_1(const char *, int, int, ...);
 int	OF_child(int);
 void	*OF_claim(void *, u_int, u_int);
 void	OF_close(int);
 void	OF_enter(void);
 void	OF_exit(void) __dead;
 int	OF_finddevice(const char *);
 int	OF_getprop(int, const char *, void *, int);
 int	OF_getproplen(int, const char *);
 int	OF_instance_to_package(int);
 int	OF_instance_to_path(int, char *, int);
 int	OF_interpret(const char *, int, int, ...);
 int	OF_milliseconds(void);
 int	OF_nextprop(int, const char *, void *);
 int	OF_open(const char *);
 int	OF_package_to_path(int, char *, int);
 int	OF_parent(int);
 int	OF_peer(int);
 void	OF_quiesce(void);
 int	OF_read(int, void *, int);
 void	OF_release(void *, u_int);
 int	OF_seek(int, u_quad_t);
 void	(*OF_set_callback(void(*)(void *)))(void *);
 int	OF_setprop(int, const char *, const void *, int);
 int	OF_write(int, const void *, int);
 int	openfirmware(void *);
 /*
  * Functions and variables provided by machine-independent code.
  */
 struct device_compatible_entry;
 int	of_compatible(int, const char * const *);
 int	of_match_compatible(int, const char * const *);
 int	of_match_compat_data(int, const struct device_compatible_entry *);
 const struct device_compatible_entry *
 	of_search_compatible(int, const struct device_compatible_entry *);
 int	of_decode_int(const unsigned char *);
 int	of_packagename(int, char *, int);
 int	of_find_firstchild_byname(int, const char *);
 int	of_find_bycompat(int, const char *);
 int	of_getnode_byname(int, const char *);
-boolean_t	of_to_uint32_prop(prop_dictionary_t, int, const char *,
+bool	of_to_uint32_prop(prop_dictionary_t, int, const char *, const char *);
-    const char *);
+bool	of_to_dataprop(prop_dictionary_t, int, const char *, const char *);
 boolean_t	of_to_dataprop(prop_dictionary_t, int, const char *,
     const char *);
 int	*of_network_decode_media(int, int *, int *);
 char	*of_get_mode_string(char *, int);
 void	of_enter_i2c_devs(prop_dictionary_t, int, size_t, int);
 void	of_enter_spi_devs(prop_dictionary_t, int, size_t);
 bool	of_hasprop(int, const char *);
 #define of_getprop_bool	of_hasprop
 int	of_getprop_uint32(int, const char *, uint32_t *);
 int	of_getprop_uint32_array(int, const char *, uint32_t *, int);
 int	of_getprop_uint64(int, const char *, uint64_t *);
 #endif /*_OPENFIRM_H_*/