 @@ -1,440 +1,440 @@
-/* $NetBSD: acpi_pci.c,v 1.18 2010/12/31 10:56:39 jruoho Exp $ */
+/* $NetBSD: acpi_pci.c,v 1.19 2015/04/13 18:32:50 christos Exp $ */
 /*
  * Copyright (c) 2009, 2010 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Christoph Egger and Gregoire Sutre.
+ *
  * 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. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * 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: acpi_pci.c,v 1.18 2010/12/31 10:56:39 jruoho Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi_pci.c,v 1.19 2015/04/13 18:32:50 christos Exp $");
 #include <sys/param.h>
 #include <sys/device.h>
 #include <sys/kmem.h>
 #include <sys/systm.h>
 #include <dev/pci/pcireg.h>
 #include <dev/pci/pcivar.h>
 #include <dev/pci/pcidevs.h>
 #include <dev/pci/ppbreg.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_pci.h>
 #include "locators.h"
 #define _COMPONENT	  ACPI_BUS_COMPONENT
 ACPI_MODULE_NAME	  ("acpi_pci")
 #define ACPI_HILODWORD(x) ACPI_HIWORD(ACPI_LODWORD((x)))
 #define ACPI_LOLODWORD(x) ACPI_LOWORD(ACPI_LODWORD((x)))
 static ACPI_STATUS	  acpi_pcidev_pciroot_bus(ACPI_HANDLE, uint16_t *);
 static ACPI_STATUS	  acpi_pcidev_pciroot_bus_callback(ACPI_RESOURCE *,
 							   void *);
 /*
  * Regarding PCI Segment Groups (ACPI 4.0, p. 277):
+ *
  * "The optional _SEG object is located under a PCI host bridge and
  *  evaluates to an integer that describes the PCI Segment Group (see PCI
  *  Firmware Specification v3.0)."
+ *
  * "PCI Segment Group is purely a software concept managed by system
  *  firmware and used by OSPM. It is a logical collection of PCI buses
  *  (or bus segments). It is a way to logically group the PCI bus segments
  *  and PCI Express Hierarchies. _SEG is a level higher than _BBN."
+ *
  * "PCI Segment Group supports more than 256 buses in a system by allowing
  *  the reuse of the PCI bus numbers.  Within each PCI Segment Group, the bus
  *  numbers for the PCI buses must be unique. PCI buses in different PCI
  *  Segment Group are permitted to have the same bus number."
  */
 /*
  * Regarding PCI Base Bus Numbers (ACPI 4.0, p. 277):
+ *
  * "For multi-root PCI platforms, the _BBN object evaluates to the PCI bus
  *  number that the BIOS assigns.  This is needed to access a PCI_Config
  *  operation region for the specified bus.  The _BBN object is located under
  *  a PCI host bridge and must be unique for every host bridge within a
  *  segment since it is the PCI bus number."
+ *
  * Moreover, the ACPI FAQ (http://www.acpi.info/acpi_faq.htm) says:
+ *
  * "For a multiple root bus machine, _BBN is required for each bus.  _BBN
  *  should provide the bus number assigned to this bus by the BIOS at boot
  *  time."
  */
 /*
  * acpi_pcidev_pciroot_bus:
+ *
  *	Derive the PCI bus number of a PCI root bridge from its resources.
  *	If successful, return AE_OK and fill *busp.  Otherwise, return an
  *	exception code and leave *busp unchanged.
  */
 static ACPI_STATUS
 acpi_pcidev_pciroot_bus(ACPI_HANDLE handle, uint16_t *busp)
+{
 	ACPI_STATUS rv;
 	int32_t bus;
 	bus = -1;
 	/*
 	 * XXX:	Use the ACPI resource parsing functions (acpi_resource.c)
 	 *	once bus number ranges have been implemented there.
 	 */
 	rv = AcpiWalkResources(handle, "_CRS",
 	    acpi_pcidev_pciroot_bus_callback, &bus);
 	if (ACPI_FAILURE(rv))
 		return rv;
 	if (bus == -1)
 		return AE_NOT_EXIST;
 	/* Here it holds that 0 <= bus <= 0xFFFF. */
 	*busp = (uint16_t)bus;
 	return rv;
+}
 static ACPI_STATUS
 acpi_pcidev_pciroot_bus_callback(ACPI_RESOURCE *res, void *context)
+{
 	ACPI_RESOURCE_ADDRESS64 addr64;
 	int32_t *bus = context;
 	/* Always continue the walk by returning AE_OK. */
 	if ((res->Type != ACPI_RESOURCE_TYPE_ADDRESS16) &&
 	    (res->Type != ACPI_RESOURCE_TYPE_ADDRESS32) &&
 	    (res->Type != ACPI_RESOURCE_TYPE_ADDRESS64))
 		return AE_OK;
 	if (ACPI_FAILURE(AcpiResourceToAddress64(res, &addr64)))
 		return AE_OK;
 	if (addr64.ResourceType != ACPI_BUS_NUMBER_RANGE)
 		return AE_OK;
 	if (*bus != -1)
 		return AE_ALREADY_EXISTS;
-	if (addr64.Minimum > 0xFFFF)
+	if (addr64.Address.Minimum > 0xFFFF)
 		return AE_BAD_DATA;
-	*bus = (int32_t)addr64.Minimum;
+	*bus = (int32_t)addr64.Address.Minimum;
 	return AE_OK;
+}
 /*
  * acpi_pcidev_scan:
+ *
  *	Scan the ACPI device tree for PCI devices.  A node is detected as a
  *	PCI device if it has an ancestor that is a PCI root bridge and such
  *	that all intermediate nodes are PCI-to-PCI bridges.  Depth-first
  *	recursive implementation.
+ *
  *	PCI root bridges do not necessarily contain an _ADR, since they already
  *	contain an _HID (ACPI 4.0a, p. 197).  However we require an _ADR for
  *	all non-root PCI devices.
  */
 ACPI_STATUS
 acpi_pcidev_scan(struct acpi_devnode *ad)
+{
 	struct acpi_devnode *child;
 	struct acpi_pci_info *ap;
 	ACPI_INTEGER val;
 	ACPI_STATUS rv;
 	ad->ad_pciinfo = NULL;
 	/*
 	 * We attach PCI information only to devices that are present,
 	 * enabled, and functioning properly.
 	 * Note: there is a possible race condition, because _STA may
 	 * have changed since ad->ad_devinfo->CurrentStatus was set.
 	 */
 	if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE)
 		goto rec;
 	if ((ad->ad_devinfo->Valid & ACPI_VALID_STA) != 0 &&
 	    (ad->ad_devinfo->CurrentStatus & ACPI_STA_OK) != ACPI_STA_OK)
 		goto rec;
 	if (ad->ad_devinfo->Flags & ACPI_PCI_ROOT_BRIDGE) {
 		ap = kmem_zalloc(sizeof(*ap), KM_SLEEP);
 		if (ap == NULL)
 			return AE_NO_MEMORY;
 		/*
 		 * If no _SEG exist, all PCI bus segments are assumed
 		 * to be in the PCI segment group 0 (ACPI 4.0, p. 277).
 		 * The segment group number is conveyed in the lower
 		 * 16 bits of _SEG (the other bits are all reserved).
 		 */
 		rv = acpi_eval_integer(ad->ad_handle, "_SEG", &val);
 		if (ACPI_SUCCESS(rv))
 			ap->ap_segment = ACPI_LOWORD(val);
 		/* Try to get downstream bus number using _CRS first. */
 		rv = acpi_pcidev_pciroot_bus(ad->ad_handle, &ap->ap_downbus);
 		if (ACPI_FAILURE(rv)) {
 			rv = acpi_eval_integer(ad->ad_handle, "_BBN", &val);
 			if (ACPI_SUCCESS(rv))
 				ap->ap_downbus = ACPI_LOWORD(val);
+		}
 		if (ap->ap_downbus > 255) {
 			aprint_error_dev(ad->ad_root,
 			    "invalid PCI downstream bus for %s\n", ad->ad_name);
 			kmem_free(ap, sizeof(*ap));
 			goto rec;
+		}
 		ap->ap_flags |= ACPI_PCI_INFO_BRIDGE;
 		/*
 		 * This ACPI node denotes a PCI root bridge, but it may also
 		 * denote a PCI device on the bridge's downstream bus segment.
 		 */
 		if (ad->ad_devinfo->Valid & ACPI_VALID_ADR) {
 			ap->ap_bus = ap->ap_downbus;
 			ap->ap_device =
 			    ACPI_HILODWORD(ad->ad_devinfo->Address);
 			ap->ap_function =
 			    ACPI_LOLODWORD(ad->ad_devinfo->Address);
 			if (ap->ap_device > 31 ||
 			    (ap->ap_function > 7 && ap->ap_function != 0xFFFF))
 				aprint_error_dev(ad->ad_root,
 				    "invalid PCI address for %s\n", ad->ad_name);
 			else
 				ap->ap_flags |= ACPI_PCI_INFO_DEVICE;
+		}
 		ad->ad_pciinfo = ap;
 		goto rec;
+	}
 	if ((ad->ad_parent != NULL) &&
 	    (ad->ad_parent->ad_pciinfo != NULL) &&
 	    (ad->ad_parent->ad_pciinfo->ap_flags & ACPI_PCI_INFO_BRIDGE) &&
 	    (ad->ad_devinfo->Valid & ACPI_VALID_ADR)) {
 		/*
 		 * Our parent is a PCI root bridge or a PCI-to-PCI
 		 * bridge. We have the same PCI segment number, and
 		 * our bus number is its downstream bus number.
 		 */
 		ap = kmem_zalloc(sizeof(*ap), KM_SLEEP);
 		if (ap == NULL)
 			return AE_NO_MEMORY;
 		ap->ap_segment = ad->ad_parent->ad_pciinfo->ap_segment;
 		ap->ap_bus = ad->ad_parent->ad_pciinfo->ap_downbus;
 		ap->ap_device = ACPI_HILODWORD(ad->ad_devinfo->Address);
 		ap->ap_function = ACPI_LOLODWORD(ad->ad_devinfo->Address);
 		if (ap->ap_device > 31 ||
 		    (ap->ap_function > 7 && ap->ap_function != 0xFFFF)) {
 			aprint_error_dev(ad->ad_root,
 			    "invalid PCI address for %s\n", ad->ad_name);
 			kmem_free(ap, sizeof(*ap));
 			goto rec;
+		}
 		ap->ap_flags |= ACPI_PCI_INFO_DEVICE;
 		if (ap->ap_function == 0xFFFF) {
 			/*
 			 * Assume that this device is not a PCI-to-PCI bridge.
 			 * XXX: Do we need to be smarter?
 			 */
 		} else {
 			/*
 			 * Check whether this device is a PCI-to-PCI
 			 * bridge and get its secondary bus number.
 			 */
 			rv = acpi_pcidev_ppb_downbus(ap->ap_segment, ap->ap_bus,
 			    ap->ap_device, ap->ap_function, &ap->ap_downbus);
 			if (ACPI_SUCCESS(rv))
 				ap->ap_flags |= ACPI_PCI_INFO_BRIDGE;
+		}
 		ad->ad_pciinfo = ap;
 		goto rec;
+	}
 rec:
 	SIMPLEQ_FOREACH(child, &ad->ad_child_head, ad_child_list) {
 		rv = acpi_pcidev_scan(child);
 		if (ACPI_FAILURE(rv))
 			return rv;
+	}
 	return AE_OK;
+}
 /*
  * acpi_pcidev_ppb_downbus:
+ *
  *	Retrieve the secondary bus number of the PCI-to-PCI bridge having the
  *	given PCI id.  If successful, return AE_OK and fill *downbus.
  *	Otherwise, return an exception code and leave *downbus unchanged.
+ *
  * XXX	Need to deal with PCI segment groups (see also acpica/OsdHardware.c).
  */
 ACPI_STATUS
 acpi_pcidev_ppb_downbus(uint16_t segment, uint16_t bus, uint16_t device,
     uint16_t function, uint16_t *downbus)
+{
 	struct acpi_softc *sc = acpi_softc;
 	pci_chipset_tag_t pc;
 	pcitag_t tag;
 	pcireg_t val;
 	if (bus > 255 || device > 31 || function > 7)
 		return AE_BAD_PARAMETER;
 	pc = sc->sc_pc;
 	tag = pci_make_tag(pc, bus, device, function);
 	/* Check that this device exists. */
 	val = pci_conf_read(pc, tag, PCI_ID_REG);
 	if (PCI_VENDOR(val) == PCI_VENDOR_INVALID ||
 	    PCI_VENDOR(val) == 0)
 		return AE_NOT_EXIST;
 	/* Check that this device is a PCI-to-PCI bridge. */
 	val = pci_conf_read(pc, tag, PCI_BHLC_REG);
 	if (PCI_HDRTYPE_TYPE(val) != PCI_HDRTYPE_PPB)
 		return AE_TYPE;
 	/* This is a PCI-to-PCI bridge.  Get its secondary bus#. */
 	val = pci_conf_read(pc, tag, PPB_REG_BUSINFO);
 	*downbus = PPB_BUSINFO_SECONDARY(val);
 	return AE_OK;
+}
 /*
  * acpi_pcidev_find:
+ *
  *      Finds a PCI device in the ACPI name space.
+ *
  *      Returns an ACPI device node on success and NULL on failure.
  */
 struct acpi_devnode *
 acpi_pcidev_find(uint16_t segment, uint16_t bus,
     uint16_t device, uint16_t function)
+{
 	struct acpi_softc *sc = acpi_softc;
 	struct acpi_devnode *ad;
 	if (sc == NULL)
 		return NULL;
 	SIMPLEQ_FOREACH(ad, &sc->ad_head, ad_list) {
 		if (ad->ad_pciinfo != NULL &&
 		    (ad->ad_pciinfo->ap_flags & ACPI_PCI_INFO_DEVICE) &&
 		    ad->ad_pciinfo->ap_segment == segment &&
 		    ad->ad_pciinfo->ap_bus == bus &&
 		    ad->ad_pciinfo->ap_device == device &&
 		    ad->ad_pciinfo->ap_function == function)
 			return ad;
+	}
 	return NULL;
+}
 /*
  * acpi_pcidev_find_dev:
+ *
  *	Returns the device corresponding to the given PCI info, or NULL
  *	if it doesn't exist.
  */
 device_t
 acpi_pcidev_find_dev(struct acpi_devnode *ad)
+{
 	struct acpi_pci_info *ap;
 	struct pci_softc *pci;
 	device_t dv, pr;
 	deviter_t di;
 	if (ad == NULL)
 		return NULL;
 	if (ad->ad_pciinfo == NULL)
 		return NULL;
 	ap = ad->ad_pciinfo;
 	if (ap->ap_function == 0xFFFF)
 		return NULL;
 	for (dv = deviter_first(&di, DEVITER_F_ROOT_FIRST);
 	     dv != NULL; dv = deviter_next(&di)) {
 		pr = device_parent(dv);
 		if (pr == NULL || device_is_a(pr, "pci") != true)
 			continue;
 		if (dv->dv_locators == NULL)	/* This should not happen. */
 			continue;
 		pci = device_private(pr);
 		if (pci->sc_bus == ap->ap_bus &&
 		    device_locator(dv, PCICF_DEV) == ap->ap_device &&
 		    device_locator(dv, PCICF_FUNCTION) == ap->ap_function)
 			break;
+	}
 	deviter_release(&di);
 	return dv;
+}

 @@ -1,842 +1,842 @@
-/*	$NetBSD: acpi_resource.c,v 1.35 2011/06/30 20:09:39 wiz Exp $	*/
+/*	$NetBSD: acpi_resource.c,v 1.36 2015/04/13 18:32:50 christos Exp $	*/
 /*
  * Copyright 2001 Wasabi Systems, Inc.
  * All rights reserved.
+ *
  * Written by Jason R. Thorpe for Wasabi Systems, Inc.
+ *
  * 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 for the NetBSD Project by
  *	Wasabi Systems, Inc.
  * 4. The name of Wasabi Systems, Inc. may not be used to endorse
  *    or promote products derived from this software without specific prior
  *    written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY WASABI SYSTEMS, INC. ``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 WASABI SYSTEMS, INC
  * 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.
  */
 /*-
  * Copyright (c) 2000 Michael Smith
  * Copyright (c) 2000 BSDi
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
  */
 /*
  * ACPI resource parsing.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: acpi_resource.c,v 1.35 2011/06/30 20:09:39 wiz Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi_resource.c,v 1.36 2015/04/13 18:32:50 christos Exp $");
 #include <sys/param.h>
 #include <sys/device.h>
 #include <sys/systm.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #define	_COMPONENT	ACPI_RESOURCE_COMPONENT
 ACPI_MODULE_NAME("RESOURCE")
 static ACPI_STATUS acpi_resource_parse_callback(ACPI_RESOURCE *, void *);
 struct resource_parse_callback_arg {
 	const struct acpi_resource_parse_ops *ops;
 	device_t dev;
 	void *context;
 };
 static ACPI_STATUS
 acpi_resource_parse_callback(ACPI_RESOURCE *res, void *context)
+{
 	struct resource_parse_callback_arg *arg = context;
 	const struct acpi_resource_parse_ops *ops;
 	int i;
 	ACPI_FUNCTION_TRACE(__func__);
 	ops = arg->ops;
 	switch (res->Type) {
 	case ACPI_RESOURCE_TYPE_FIXED_IO:
 		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				     "FixedIo 0x%x/%u\n",
 				     res->Data.FixedIo.Address,
 				     res->Data.FixedIo.AddressLength));
 		if (ops->ioport)
 			(*ops->ioport)(arg->dev, arg->context,
 			    res->Data.FixedIo.Address,
 			    res->Data.FixedIo.AddressLength);
 		break;
 	case ACPI_RESOURCE_TYPE_IO:
 		if (res->Data.Io.Minimum ==
 		    res->Data.Io.Maximum) {
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 					     "Io 0x%x/%u\n",
 					     res->Data.Io.Minimum,
 					     res->Data.Io.AddressLength));
 			if (ops->ioport)
 				(*ops->ioport)(arg->dev, arg->context,
 				    res->Data.Io.Minimum,
 				    res->Data.Io.AddressLength);
 		} else {
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 					     "Io 0x%x-0x%x/%u\n",
 					     res->Data.Io.Minimum,
 					     res->Data.Io.Maximum,
 					     res->Data.Io.AddressLength));
 			if (ops->iorange)
 				(*ops->iorange)(arg->dev, arg->context,
 				    res->Data.Io.Minimum,
 				    res->Data.Io.Maximum,
 				    res->Data.Io.AddressLength,
 				    res->Data.Io.Alignment);
+		}
 		break;
 	case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
 		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				     "FixedMemory32 0x%x/%u\n",
 				     res->Data.FixedMemory32.Address,
 				     res->Data.FixedMemory32.AddressLength));
 		if (ops->memory)
 			(*ops->memory)(arg->dev, arg->context,
 			    res->Data.FixedMemory32.Address,
 			    res->Data.FixedMemory32.AddressLength);
 		break;
 	case ACPI_RESOURCE_TYPE_MEMORY32:
 		if (res->Data.Memory32.Minimum ==
 		    res->Data.Memory32.Maximum) {
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 					     "Memory32 0x%x/%u\n",
 					     res->Data.Memory32.Minimum,
 					     res->Data.Memory32.AddressLength));
 			if (ops->memory)
 				(*ops->memory)(arg->dev, arg->context,
 				    res->Data.Memory32.Minimum,
 				    res->Data.Memory32.AddressLength);
 		} else {
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 					     "Memory32 0x%x-0x%x/%u\n",
 					     res->Data.Memory32.Minimum,
 					     res->Data.Memory32.Maximum,
 					     res->Data.Memory32.AddressLength));
 			if (ops->memrange)
 				(*ops->memrange)(arg->dev, arg->context,
 				    res->Data.Memory32.Minimum,
 				    res->Data.Memory32.Maximum,
 				    res->Data.Memory32.AddressLength,
 				    res->Data.Memory32.Alignment);
+		}
 		break;
 	case ACPI_RESOURCE_TYPE_MEMORY24:
 		if (res->Data.Memory24.Minimum ==
 		    res->Data.Memory24.Maximum) {
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 					     "Memory24 0x%x/%u\n",
 					     res->Data.Memory24.Minimum,
 					     res->Data.Memory24.AddressLength));
 			if (ops->memory)
 				(*ops->memory)(arg->dev, arg->context,
 				    res->Data.Memory24.Minimum,
 				    res->Data.Memory24.AddressLength);
 		} else {
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 					     "Memory24 0x%x-0x%x/%u\n",
 					     res->Data.Memory24.Minimum,
 					     res->Data.Memory24.Maximum,
 					     res->Data.Memory24.AddressLength));
 			if (ops->memrange)
 				(*ops->memrange)(arg->dev, arg->context,
 				    res->Data.Memory24.Minimum,
 				    res->Data.Memory24.Maximum,
 				    res->Data.Memory24.AddressLength,
 				    res->Data.Memory24.Alignment);
+		}
 		break;
 	case ACPI_RESOURCE_TYPE_IRQ:
 		for (i = 0; i < res->Data.Irq.InterruptCount; i++) {
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 					     "IRQ %u\n",
 					     res->Data.Irq.Interrupts[i]));
 			if (ops->irq)
 				(*ops->irq)(arg->dev, arg->context,
 				    res->Data.Irq.Interrupts[i],
 				    res->Data.Irq.Triggering);
+		}
 		break;
 	case ACPI_RESOURCE_TYPE_DMA:
 		for (i = 0; i < res->Data.Dma.ChannelCount; i++) {
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 					     "DRQ %u\n",
 					     res->Data.Dma.Channels[i]));
 			if (ops->drq)
 				(*ops->drq)(arg->dev, arg->context,
 				    res->Data.Dma.Channels[i]);
+		}
 		break;
 	case ACPI_RESOURCE_TYPE_START_DEPENDENT:
 		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				     "Start dependent functions: %u\n",
 				     res->Data.StartDpf.CompatibilityPriority));
 		if (ops->start_dep)
 			(*ops->start_dep)(arg->dev, arg->context,
 			    res->Data.StartDpf.CompatibilityPriority);
 		break;
 	case ACPI_RESOURCE_TYPE_END_DEPENDENT:
 		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				     "End dependent functions\n"));
 		if (ops->end_dep)
 			(*ops->end_dep)(arg->dev, arg->context);
 		break;
 	case ACPI_RESOURCE_TYPE_ADDRESS32:
 		/* XXX Only fixed size supported for now */
-		if (res->Data.Address32.AddressLength == 0 ||
+		if (res->Data.Address32.Address.AddressLength == 0 ||
 		    res->Data.Address32.ProducerConsumer != ACPI_CONSUMER)
 			break;
 #define ADRRESS32_FIXED2(r)						\
 	((r)->Data.Address32.MinAddressFixed == ACPI_ADDRESS_FIXED &&	\
 	 (r)->Data.Address32.MaxAddressFixed == ACPI_ADDRESS_FIXED)
 		switch (res->Data.Address32.ResourceType) {
 		case ACPI_MEMORY_RANGE:
 			if (ADRRESS32_FIXED2(res)) {
 				if (ops->memory)
 					(*ops->memory)(arg->dev, arg->context,
-					    res->Data.Address32.Minimum,
+					    res->Data.Address32.Address.Minimum,
-					    res->Data.Address32.AddressLength);
+					    res->Data.Address32.Address.AddressLength);
 			} else {
 				if (ops->memrange)
 					(*ops->memrange)(arg->dev, arg->context,
-					    res->Data.Address32.Minimum,
+					    res->Data.Address32.Address.Minimum,
-					    res->Data.Address32.Maximum,
+					    res->Data.Address32.Address.Maximum,
-					    res->Data.Address32.AddressLength,
+					    res->Data.Address32.Address.AddressLength,
-					    res->Data.Address32.Granularity);
+					    res->Data.Address32.Address.Granularity);
+			}
 			break;
 		case ACPI_IO_RANGE:
 			if (ADRRESS32_FIXED2(res)) {
 				if (ops->ioport)
 					(*ops->ioport)(arg->dev, arg->context,
-					    res->Data.Address32.Minimum,
+					    res->Data.Address32.Address.Minimum,
-					    res->Data.Address32.AddressLength);
+					    res->Data.Address32.Address.AddressLength);
 			} else {
 				if (ops->iorange)
 					(*ops->iorange)(arg->dev, arg->context,
-					    res->Data.Address32.Minimum,
+					    res->Data.Address32.Address.Minimum,
-					    res->Data.Address32.Maximum,
+					    res->Data.Address32.Address.Maximum,
-					    res->Data.Address32.AddressLength,
+					    res->Data.Address32.Address.AddressLength,
-					    res->Data.Address32.Granularity);
+					    res->Data.Address32.Address.Granularity);
+			}
 			break;
 		case ACPI_BUS_NUMBER_RANGE:
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				      "Address32/BusNumber unimplemented\n"));
 			break;
+		}
 #undef ADRRESS32_FIXED2
 		break;
 	case ACPI_RESOURCE_TYPE_ADDRESS16:
 		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				     "Address16 unimplemented\n"));
 		break;
 	case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
 		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				     "Extended address64 unimplemented\n"));
 		break;
 	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 		if (res->Data.ExtendedIrq.ProducerConsumer != ACPI_CONSUMER) {
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 			    "ignored ExtIRQ producer\n"));
 			break;
+		}
 		for (i = 0; i < res->Data.ExtendedIrq.InterruptCount; i++) {
 			ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				     "ExtIRQ %u\n",
 				     res->Data.ExtendedIrq.Interrupts[i]));
 			if (ops->irq)
 				(*ops->irq)(arg->dev, arg->context,
 				    res->Data.ExtendedIrq.Interrupts[i],
 				    res->Data.ExtendedIrq.Triggering);
+		}
 		break;
 	case ACPI_RESOURCE_TYPE_GENERIC_REGISTER:
 		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				     "GenericRegister unimplemented\n"));
 		break;
 	case ACPI_RESOURCE_TYPE_VENDOR:
 		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				     "VendorSpecific unimplemented\n"));
 		break;
 	default:
 		ACPI_DEBUG_PRINT((ACPI_DB_RESOURCES,
 				     "Unknown resource type: %u\n", res->Type));
 		break;
+	}
 	return_ACPI_STATUS(AE_OK);
+}
 /*
  * acpi_resource_parse:
+ *
  *	Parse a device node's resources and fill them in for the
  *	client.
+ *
  *	This API supports _CRS (current resources) and
  *	_PRS (possible resources).
+ *
  *	Note that it might be nice to also locate ACPI-specific resource
  *	items, such as GPE bits.
  */
 ACPI_STATUS
 acpi_resource_parse(device_t dev, ACPI_HANDLE handle, const char *path,
     void *arg, const struct acpi_resource_parse_ops *ops)
+{
 	struct resource_parse_callback_arg cbarg;
 	ACPI_STATUS rv;
 	ACPI_FUNCTION_TRACE(__func__);
 	if (ops->init)
 		(*ops->init)(dev, arg, &cbarg.context);
 	else
 		cbarg.context = arg;
 	cbarg.ops = ops;
 	cbarg.dev = dev;
 	rv = AcpiWalkResources(handle, path, acpi_resource_parse_callback,
 	    &cbarg);
 	if (ACPI_FAILURE(rv)) {
 		aprint_error_dev(dev, "ACPI: unable to get %s resources: %s\n",
 		    path, AcpiFormatException(rv));
 		return_ACPI_STATUS(rv);
+	}
 	if (ops->fini)
 		(*ops->fini)(dev, cbarg.context);
 	return_ACPI_STATUS(AE_OK);
+}
 /*
  * acpi_resource_print:
+ *
  *	Print the resources assigned to a device.
  */
 void
 acpi_resource_print(device_t dev, struct acpi_resources *res)
+{
 	const char *sep;
 	if (SIMPLEQ_EMPTY(&res->ar_io) &&
 	    SIMPLEQ_EMPTY(&res->ar_iorange) &&
 	    SIMPLEQ_EMPTY(&res->ar_mem) &&
 	    SIMPLEQ_EMPTY(&res->ar_memrange) &&
 	    SIMPLEQ_EMPTY(&res->ar_irq) &&
 	    SIMPLEQ_EMPTY(&res->ar_drq))
 		return;
 	aprint_normal(":");
 	if (SIMPLEQ_EMPTY(&res->ar_io) == 0) {
 		struct acpi_io *ar;
 		sep = "";
 		aprint_normal(" io ");
 		SIMPLEQ_FOREACH(ar, &res->ar_io, ar_list) {
 			aprint_normal("%s0x%x", sep, ar->ar_base);
 			if (ar->ar_length > 1)
 				aprint_normal("-0x%x", ar->ar_base +
 				    ar->ar_length - 1);
 			sep = ",";
+		}
+	}
 	/* XXX iorange */
 	if (SIMPLEQ_EMPTY(&res->ar_mem) == 0) {
 		struct acpi_mem *ar;
 		sep = "";
 		aprint_normal(" mem ");
 		SIMPLEQ_FOREACH(ar, &res->ar_mem, ar_list) {
 			aprint_normal("%s0x%x", sep, ar->ar_base);
 			if (ar->ar_length > 1)
 				aprint_normal("-0x%x", ar->ar_base +
 				    ar->ar_length - 1);
 			sep = ",";
+		}
+	}
 	/* XXX memrange */
 	if (SIMPLEQ_EMPTY(&res->ar_irq) == 0) {
 		struct acpi_irq *ar;
 		sep = "";
 		aprint_normal(" irq ");
 		SIMPLEQ_FOREACH(ar, &res->ar_irq, ar_list) {
 			aprint_normal("%s%d", sep, ar->ar_irq);
 			sep = ",";
+		}
+	}
 	if (SIMPLEQ_EMPTY(&res->ar_drq) == 0) {
 		struct acpi_drq *ar;
 		sep = "";
 		aprint_normal(" drq ");
 		SIMPLEQ_FOREACH(ar, &res->ar_drq, ar_list) {
 			aprint_normal("%s%d", sep, ar->ar_drq);
 			sep = ",";
+		}
+	}
 	aprint_normal("\n");
 	aprint_naive("\n");
+}
 /*
  * acpi_resource_cleanup:
+ *
  *	Free all allocated buffers
  */
 void
 acpi_resource_cleanup(struct acpi_resources *res)
+{
 	while (!SIMPLEQ_EMPTY(&res->ar_io)) {
 		struct acpi_io *ar;
 		ar = SIMPLEQ_FIRST(&res->ar_io);
 		SIMPLEQ_REMOVE_HEAD(&res->ar_io, ar_list);
 		ACPI_FREE(ar);
+	}
 	while (!SIMPLEQ_EMPTY(&res->ar_iorange)) {
 		struct acpi_iorange *ar;
 		ar = SIMPLEQ_FIRST(&res->ar_iorange);
 		SIMPLEQ_REMOVE_HEAD(&res->ar_iorange, ar_list);
 		ACPI_FREE(ar);
+	}
 	while (!SIMPLEQ_EMPTY(&res->ar_mem)) {
 		struct acpi_mem *ar;
 		ar = SIMPLEQ_FIRST(&res->ar_mem);
 		SIMPLEQ_REMOVE_HEAD(&res->ar_mem, ar_list);
 		ACPI_FREE(ar);
+	}
 	while (!SIMPLEQ_EMPTY(&res->ar_memrange)) {
 		struct acpi_memrange *ar;
 		ar = SIMPLEQ_FIRST(&res->ar_memrange);
 		SIMPLEQ_REMOVE_HEAD(&res->ar_memrange, ar_list);
 		ACPI_FREE(ar);
+	}
 	while (!SIMPLEQ_EMPTY(&res->ar_irq)) {
 		struct acpi_irq *ar;
 		ar = SIMPLEQ_FIRST(&res->ar_irq);
 		SIMPLEQ_REMOVE_HEAD(&res->ar_irq, ar_list);
 		ACPI_FREE(ar);
+	}
 	while (!SIMPLEQ_EMPTY(&res->ar_drq)) {
 		struct acpi_drq *ar;
 		ar = SIMPLEQ_FIRST(&res->ar_drq);
 		SIMPLEQ_REMOVE_HEAD(&res->ar_drq, ar_list);
 		ACPI_FREE(ar);
+	}
 	res->ar_nio = res->ar_niorange = res->ar_nmem =
 	    res->ar_nmemrange = res->ar_nirq = res->ar_ndrq = 0;
+}
 struct acpi_io *
 acpi_res_io(struct acpi_resources *res, int idx)
+{
 	struct acpi_io *ar;
 	SIMPLEQ_FOREACH(ar, &res->ar_io, ar_list) {
 		if (ar->ar_index == idx)
 			return ar;
+	}
 	return NULL;
+}
 struct acpi_iorange *
 acpi_res_iorange(struct acpi_resources *res, int idx)
+{
 	struct acpi_iorange *ar;
 	SIMPLEQ_FOREACH(ar, &res->ar_iorange, ar_list) {
 		if (ar->ar_index == idx)
 			return ar;
+	}
 	return NULL;
+}
 struct acpi_mem *
 acpi_res_mem(struct acpi_resources *res, int idx)
+{
 	struct acpi_mem *ar;
 	SIMPLEQ_FOREACH(ar, &res->ar_mem, ar_list) {
 		if (ar->ar_index == idx)
 			return ar;
+	}
 	return NULL;
+}
 struct acpi_memrange *
 acpi_res_memrange(struct acpi_resources *res, int idx)
+{
 	struct acpi_memrange *ar;
 	SIMPLEQ_FOREACH(ar, &res->ar_memrange, ar_list) {
 		if (ar->ar_index == idx)
 			return ar;
+	}
 	return NULL;
+}
 struct acpi_irq *
 acpi_res_irq(struct acpi_resources *res, int idx)
+{
 	struct acpi_irq *ar;
 	SIMPLEQ_FOREACH(ar, &res->ar_irq, ar_list) {
 		if (ar->ar_index == idx)
 			return ar;
+	}
 	return NULL;
+}
 struct acpi_drq *
 acpi_res_drq(struct acpi_resources *res, int idx)
+{
 	struct acpi_drq *ar;
 	SIMPLEQ_FOREACH(ar, &res->ar_drq, ar_list) {
 		if (ar->ar_index == idx)
 			return ar;
+	}
 	return NULL;
+}
 /*****************************************************************************
  * Default ACPI resource parse operations.
  *****************************************************************************/
 static void	acpi_res_parse_init(device_t, void *, void **);
 static void	acpi_res_parse_fini(device_t, void *);
 static void	acpi_res_parse_ioport(device_t, void *, uint32_t,
 		    uint32_t);
 static void	acpi_res_parse_iorange(device_t, void *, uint32_t,
 		    uint32_t, uint32_t, uint32_t);
 static void	acpi_res_parse_memory(device_t, void *, uint32_t,
 		    uint32_t);
 static void	acpi_res_parse_memrange(device_t, void *, uint32_t,
 		    uint32_t, uint32_t, uint32_t);
 static void	acpi_res_parse_irq(device_t, void *, uint32_t, uint32_t);
 static void	acpi_res_parse_drq(device_t, void *, uint32_t);
 static void	acpi_res_parse_start_dep(device_t, void *, int);
 static void	acpi_res_parse_end_dep(device_t, void *);
 const struct acpi_resource_parse_ops acpi_resource_parse_ops_default = {
 	.init = acpi_res_parse_init,
 	.fini = acpi_res_parse_fini,
 	.ioport = acpi_res_parse_ioport,
 	.iorange = acpi_res_parse_iorange,
 	.memory = acpi_res_parse_memory,
 	.memrange = acpi_res_parse_memrange,
 	.irq = acpi_res_parse_irq,
 	.drq = acpi_res_parse_drq,
 	.start_dep = acpi_res_parse_start_dep,
 	.end_dep = acpi_res_parse_end_dep,
 };
 const struct acpi_resource_parse_ops acpi_resource_parse_ops_quiet = {
 	.init = acpi_res_parse_init,
 	.fini = NULL,
 	.ioport = acpi_res_parse_ioport,
 	.iorange = acpi_res_parse_iorange,
 	.memory = acpi_res_parse_memory,
 	.memrange = acpi_res_parse_memrange,
 	.irq = acpi_res_parse_irq,
 	.drq = acpi_res_parse_drq,
 	.start_dep = acpi_res_parse_start_dep,
 	.end_dep = acpi_res_parse_end_dep,
 };
 static void
 acpi_res_parse_init(device_t dev, void *arg, void **contextp)
+{
 	struct acpi_resources *res = arg;
 	SIMPLEQ_INIT(&res->ar_io);
 	res->ar_nio = 0;
 	SIMPLEQ_INIT(&res->ar_iorange);
 	res->ar_niorange = 0;
 	SIMPLEQ_INIT(&res->ar_mem);
 	res->ar_nmem = 0;
 	SIMPLEQ_INIT(&res->ar_memrange);
 	res->ar_nmemrange = 0;
 	SIMPLEQ_INIT(&res->ar_irq);
 	res->ar_nirq = 0;
 	SIMPLEQ_INIT(&res->ar_drq);
 	res->ar_ndrq = 0;
 	*contextp = res;
+}
 static void
 acpi_res_parse_fini(device_t dev, void *context)
+{
 	struct acpi_resources *res = context;
 	/* Print the resources we're using. */
 	acpi_resource_print(dev, res);
+}
 static void
 acpi_res_parse_ioport(device_t dev, void *context, uint32_t base,
     uint32_t length)
+{
 	struct acpi_resources *res = context;
 	struct acpi_io *ar;
 	/*
 	 * Check if there is another I/O port directly below/under
 	 * this one.
 	 */
 	SIMPLEQ_FOREACH(ar, &res->ar_io, ar_list) {
 		if (ar->ar_base == base + length ) {
 			/*
 			 * Entry just below existing entry - adjust
 			 * the entry and return.
 			 */
 			ar->ar_base = base;
 			ar->ar_length += length;
 			return;
 		} else if (ar->ar_base + ar->ar_length == base) {
 			/*
 			 * Entry just above existing entry - adjust
 			 * the entry and return.
 			 */
 			ar->ar_length += length;
 			return;
+		}
+	}
 	ar = ACPI_ALLOCATE(sizeof(*ar));
 	if (ar == NULL) {
 		aprint_error_dev(dev, "ACPI: unable to allocate I/O resource %d\n",
 		    res->ar_nio);
 		res->ar_nio++;
 		return;
+	}
 	ar->ar_index = res->ar_nio++;
 	ar->ar_base = base;
 	ar->ar_length = length;
 	SIMPLEQ_INSERT_TAIL(&res->ar_io, ar, ar_list);
+}
 static void
 acpi_res_parse_iorange(device_t dev, void *context, uint32_t low,
     uint32_t high, uint32_t length, uint32_t align)
+{
 	struct acpi_resources *res = context;
 	struct acpi_iorange *ar;
 	ar = ACPI_ALLOCATE(sizeof(*ar));
 	if (ar == NULL) {
 		aprint_error_dev(dev, "ACPI: unable to allocate I/O range resource %d\n",
 		    res->ar_niorange);
 		res->ar_niorange++;
 		return;
+	}
 	ar->ar_index = res->ar_niorange++;
 	ar->ar_low = low;
 	ar->ar_high = high;
 	ar->ar_length = length;
 	ar->ar_align = align;
 	SIMPLEQ_INSERT_TAIL(&res->ar_iorange, ar, ar_list);
+}
 static void
 acpi_res_parse_memory(device_t dev, void *context, uint32_t base,
     uint32_t length)
+{
 	struct acpi_resources *res = context;
 	struct acpi_mem *ar;
 	ar = ACPI_ALLOCATE(sizeof(*ar));
 	if (ar == NULL) {
 		aprint_error_dev(dev, "ACPI: unable to allocate Memory resource %d\n",
 		    res->ar_nmem);
 		res->ar_nmem++;
 		return;
+	}
 	ar->ar_index = res->ar_nmem++;
 	ar->ar_base = base;
 	ar->ar_length = length;
 	SIMPLEQ_INSERT_TAIL(&res->ar_mem, ar, ar_list);
+}
 static void
 acpi_res_parse_memrange(device_t dev, void *context, uint32_t low,
     uint32_t high, uint32_t length, uint32_t align)
+{
 	struct acpi_resources *res = context;
 	struct acpi_memrange *ar;
 	ar = ACPI_ALLOCATE(sizeof(*ar));
 	if (ar == NULL) {
 		aprint_error_dev(dev, "ACPI: unable to allocate Memory range resource %d\n",
 		    res->ar_nmemrange);
 		res->ar_nmemrange++;
 		return;
+	}
 	ar->ar_index = res->ar_nmemrange++;
 	ar->ar_low = low;
 	ar->ar_high = high;
 	ar->ar_length = length;
 	ar->ar_align = align;
 	SIMPLEQ_INSERT_TAIL(&res->ar_memrange, ar, ar_list);
+}
 static void
 acpi_res_parse_irq(device_t dev, void *context, uint32_t irq, uint32_t type)
+{
 	struct acpi_resources *res = context;
 	struct acpi_irq *ar;
 	ar = ACPI_ALLOCATE(sizeof(*ar));
 	if (ar == NULL) {
 		aprint_error_dev(dev, "ACPI: unable to allocate IRQ resource %d\n",
 		    res->ar_nirq);
 		res->ar_nirq++;
 		return;
+	}
 	ar->ar_index = res->ar_nirq++;
 	ar->ar_irq = irq;
 	ar->ar_type = type;
 	SIMPLEQ_INSERT_TAIL(&res->ar_irq, ar, ar_list);
+}
 static void
 acpi_res_parse_drq(device_t dev, void *context, uint32_t drq)
+{
 	struct acpi_resources *res = context;
 	struct acpi_drq *ar;
 	ar = ACPI_ALLOCATE(sizeof(*ar));
 	if (ar == NULL) {
 		aprint_error_dev(dev, "ACPI: unable to allocate DRQ resource %d\n",
 		    res->ar_ndrq);
 		res->ar_ndrq++;
 		return;
+	}
 	ar->ar_index = res->ar_ndrq++;
 	ar->ar_drq = drq;
 	SIMPLEQ_INSERT_TAIL(&res->ar_drq, ar, ar_list);
+}
 static void
 acpi_res_parse_start_dep(device_t dev, void *context,
     int preference)
+{
 	aprint_error_dev(dev, "ACPI: dependent functions not supported\n");
+}
 static void
 acpi_res_parse_end_dep(device_t dev, void *context)
+{
 	/* Nothing to do. */
+}