 @@ -1,189 +1,189 @@
-/* $NetBSD: bcm2835_bsc_acpi.c,v 1.1 2020/03/31 12:23:17 jmcneill Exp $ */
+/* $NetBSD: bcm2835_bsc_acpi.c,v 1.2 2021/01/26 00:19:52 jmcneill Exp $ */
 /*-
  * Copyright (c) 2020 Jared McNeill <jmcneill@invisible.ca>
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: bcm2835_bsc_acpi.c,v 1.1 2020/03/31 12:23:17 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: bcm2835_bsc_acpi.c,v 1.2 2021/01/26 00:19:52 jmcneill Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_intr.h>
 #include <dev/acpi/acpi_i2c.h>
 #include <arm/broadcom/bcm2835var.h>
 #include <arm/broadcom/bcm2835_mbox.h>
 #include <arm/broadcom/bcm2835_bscvar.h>
 #include <evbarm/rpi/vcio.h>
 #include <evbarm/rpi/vcpm.h>
 #include <evbarm/rpi/vcprop.h>
 static int	bsciic_acpi_match(device_t, cfdata_t, void *);
 static void	bsciic_acpi_attach(device_t, device_t, void *);
 static u_int	bsciic_acpi_vpu_clock_rate(void);
 CFATTACH_DECL_NEW(bsciic_acpi, sizeof(struct bsciic_softc), bsciic_acpi_match, bsciic_acpi_attach, NULL, NULL);
 static const char * const compatible[] = {
 	"BCM2841",
 	NULL
 };
 static struct {
 	struct vcprop_buffer_hdr	vb_hdr;
 	struct vcprop_tag_clockrate	vbt_vpuclockrate;
 	struct vcprop_tag end;
 } vb_vpu __cacheline_aligned = {
 	.vb_hdr = {
 		.vpb_len = sizeof(vb_vpu),
 		.vpb_rcode = VCPROP_PROCESS_REQUEST
 	},
 	.vbt_vpuclockrate = {
 		.tag = {
 			.vpt_tag = VCPROPTAG_GET_CLOCKRATE,
 			.vpt_len = VCPROPTAG_LEN(vb_vpu.vbt_vpuclockrate),
 			.vpt_rcode = VCPROPTAG_REQUEST
 		},
 		.id = VCPROP_CLK_CORE
 	},
 	.end = {
 		.vpt_tag = VCPROPTAG_NULL
+	}
 };
 static int
 bsciic_acpi_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct acpi_attach_args *aa = aux;
 	if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
 		return 0;
 	return acpi_match_hid(aa->aa_node->ad_devinfo, compatible);
+}
 static void
 bsciic_acpi_attach(device_t parent, device_t self, void *aux)
+{
 	struct bsciic_softc * const sc = device_private(self);
 	struct acpi_attach_args *aa = aux;
 	struct i2cbus_attach_args iba;
 	struct acpi_resources res;
 	struct acpi_mem *mem;
 	struct acpi_irq *irq;
 	ACPI_STATUS rv;
 	ACPI_INTEGER clock_freq;
 	void *ih;
 	sc->sc_dev = self;
 	rv = acpi_resource_parse(sc->sc_dev, aa->aa_node->ad_handle, "_CRS",
 	    &res, &acpi_resource_parse_ops_default);
 	if (ACPI_FAILURE(rv))
 		return;
 	mem = acpi_res_mem(&res, 0);
 	if (mem == NULL) {
 		aprint_error_dev(self, "couldn't find mem resource\n");
 		goto done;
+	}
 	irq = acpi_res_irq(&res, 0);
 	if (irq == NULL) {
 		aprint_error_dev(self, "couldn't find irq resource\n");
 		goto done;
+	}
 	sc->sc_dev = self;
 	sc->sc_iot = aa->aa_memt;
 	if (bus_space_map(aa->aa_memt, mem->ar_base, mem->ar_length, 0, &sc->sc_ioh) != 0) {
 		aprint_error_dev(self, "couldn't map registers\n");
 		goto done;
+	}
 	sc->sc_frequency = bsciic_acpi_vpu_clock_rate();
 	if (sc->sc_frequency == 0) {
 		aprint_error_dev(self, "couldn't determine parent clock rate\n");
 		goto done;
+	}
 	rv = acpi_dsd_integer(aa->aa_node->ad_handle, "clock-frequency", &clock_freq);
 	if (ACPI_SUCCESS(rv))
 		sc->sc_clkrate = clock_freq;
 	else
 		sc->sc_clkrate = 100000;
 	bsciic_attach(sc);
 	ih = acpi_intr_establish(self, (uint64_t)aa->aa_node->ad_handle,
 	    IPL_VM, true, bsciic_intr, sc, device_xname(self));
 	if (ih == NULL) {
 		aprint_error_dev(self, "couldn't install interrupt handler\n");
 		goto done;
+	}
 	iic_tag_init(&sc->sc_i2c);
 	sc->sc_i2c.ic_cookie = sc;
 	sc->sc_i2c.ic_acquire_bus = bsciic_acquire_bus;
 	sc->sc_i2c.ic_release_bus = bsciic_release_bus;
 	sc->sc_i2c.ic_exec = bsciic_exec;
 	memset(&iba, 0, sizeof(iba));
 	iba.iba_tag = &sc->sc_i2c;
-	iba.iba_child_devices = acpi_enter_i2c_devs(aa->aa_node);
+	iba.iba_child_devices = acpi_enter_i2c_devs(self, aa->aa_node);
 	config_found_ia(self, "i2cbus", &iba, iicbus_print);
 done:
 	acpi_resource_cleanup(&res);
+}
 static u_int
 bsciic_acpi_vpu_clock_rate(void)
+{
 	uint32_t res;
 	int error;
 	error = bcmmbox_request(BCMMBOX_CHANARM2VC, &vb_vpu,
 	    sizeof(vb_vpu), &res);
 	if (error != 0) {
 		printf("%s: mbox request failed (%d)\n", __func__, error);
 		return 0;
+	}
 	if (!vcprop_buffer_success_p(&vb_vpu.vb_hdr) ||
 	    !vcprop_tag_success_p(&vb_vpu.vbt_vpuclockrate.tag) ||
 	    vb_vpu.vbt_vpuclockrate.rate < 0)
 		return 0;
 	return vb_vpu.vbt_vpuclockrate.rate;
+}

 @@ -1,215 +1,215 @@
-/* $NetBSD: dwiic_pci.c,v 1.2 2018/09/26 19:06:33 jakllsch Exp $ */
+/* $NetBSD: dwiic_pci.c,v 1.3 2021/01/26 00:19:52 jmcneill Exp $ */
 /*-
  * Copyright (c) 2017 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Manuel Bouyer.
+ *
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 /*
  * Synopsys DesignWare I2C controller, PCI front-end
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: dwiic_pci.c,v 1.2 2018/09/26 19:06:33 jakllsch Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dwiic_pci.c,v 1.3 2021/01/26 00:19:52 jmcneill Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <dev/pci/pcireg.h>
 #include <dev/pci/pcivar.h>
 #include <dev/pci/pcidevs.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_pci.h>
 #include <dev/acpi/acpi_util.h>
 #include <dev/acpi/acpi_i2c.h>
 #include <dev/ic/dwiic_var.h>
 #include <arch/x86/pci/lpssreg.h>
 //#define DWIIC_DEBUG
 #ifdef DWIIC_DEBUG
 #define DPRINTF(x) printf x
 #else
 #define DPRINTF(x)
 #endif
 struct pci_dwiic_softc {
 	struct dwiic_softc	sc_dwiic;
 	pci_chipset_tag_t	sc_pc;
 	pcitag_t		sc_ptag;
 	struct acpi_devnode	*sc_acpinode;
 };
 static uint32_t
 lpss_read(struct pci_dwiic_softc *sc, int offset)
+{
 	u_int32_t b = bus_space_read_4(sc->sc_dwiic.sc_iot, sc->sc_dwiic.sc_ioh,
 	     offset);
 	return b;
+}
 static void
 lpss_write(struct pci_dwiic_softc *sc, int offset, uint32_t val)
+{
 	bus_space_write_4(sc->sc_dwiic.sc_iot, sc->sc_dwiic.sc_ioh,
 	    offset, val);
+}
 static int	pci_dwiic_match(device_t, cfdata_t, void *);
 static void	pci_dwiic_attach(device_t, device_t, void *);
 static bool	dwiic_pci_power(struct dwiic_softc *, bool);
 CFATTACH_DECL_NEW(pcidwiic, sizeof(struct pci_dwiic_softc),
     pci_dwiic_match, pci_dwiic_attach, dwiic_detach, NULL);
 int
 pci_dwiic_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct pci_attach_args *pa = aux;
 	if (PCI_VENDOR(pa->pa_id) != PCI_VENDOR_INTEL)
 		return 0;
 	if (PCI_PRODUCT(pa->pa_id) < PCI_PRODUCT_INTEL_100SERIES_LP_I2C_0 ||
 	    PCI_PRODUCT(pa->pa_id) > PCI_PRODUCT_INTEL_100SERIES_LP_I2C_3)
 		return 0;
 	return 1;
+}
 void
 pci_dwiic_attach(device_t parent, device_t self, void *aux)
+{
 	struct pci_dwiic_softc *sc = device_private(self);
 	struct pci_attach_args *pa = aux;
 	const char *intrstr;
 	pci_intr_handle_t intrhandle;
 	char intrbuf[PCI_INTRSTR_LEN];
 	pcireg_t memtype;
 	pcireg_t csr;
 	uint32_t caps;
 	sc->sc_dwiic.sc_dev = self;
 	sc->sc_dwiic.sc_power = dwiic_pci_power;
 	sc->sc_dwiic.sc_type = dwiic_type_sunrisepoint;
 	sc->sc_pc = pa->pa_pc;
 	sc->sc_ptag = pa->pa_tag;
 	/* register access not enabled by BIOS */
 	csr = pci_conf_read(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG);
 	pci_conf_write(pa->pa_pc, pa->pa_tag, PCI_COMMAND_STATUS_REG,
 	    csr | PCI_COMMAND_MEM_ENABLE);
 	memtype = pci_mapreg_type(pa->pa_pc, pa->pa_tag, PCI_BAR0);
 	if (pci_mapreg_map(pa, PCI_BAR0, memtype, 0, &sc->sc_dwiic.sc_iot,
 	    &sc->sc_dwiic.sc_ioh, NULL, NULL) != 0) {
 		aprint_error(": can't map register space\n");
 		goto out;
+	}
 	dwiic_pci_power(&sc->sc_dwiic, 1);
 	caps = lpss_read(sc, LPSS_CAP);
 	aprint_naive(": I2C controller\n");
 	aprint_normal(": I2C controller instance %d\n",
 	    (int)(caps & LPSS_CAP_INSTANCE));
 	if (pci_intr_map(pa, &intrhandle)) {
 		aprint_error_dev(self, "can't map interrupt\n");
 		goto out;
+	}
 	intrstr = pci_intr_string(pa->pa_pc, intrhandle,
 	    intrbuf, sizeof(intrbuf));
 	sc->sc_dwiic.sc_ih = pci_intr_establish(pa->pa_pc, intrhandle,
 	    IPL_VM, dwiic_intr, sc);
 	if (sc->sc_dwiic.sc_ih == NULL) {
 		aprint_error_dev(self, "couldn't establish interrupt");
 		if (intrstr != NULL)
 			aprint_error(" at %s", intrstr);
 		aprint_error("\n");
 		goto out;
+	}
 	aprint_normal_dev(self, "interrupting at %s\n", intrstr);
 	lpss_write(sc, LPSS_RESET, LPSS_RESET_CTRL_REL);
 	lpss_write(sc, LPSS_REMAP_LO,
 	    pci_conf_read(sc->sc_pc, sc->sc_ptag, PCI_BAR0));
 	lpss_write(sc, LPSS_REMAP_HI,
 	    pci_conf_read(sc->sc_pc, sc->sc_ptag, PCI_BAR0 + 0x4));
 	sc->sc_acpinode = acpi_pcidev_find(0 /*XXX segment*/,
 	    pa->pa_bus, pa->pa_device, pa->pa_function);
 	if (sc->sc_acpinode) {
 		sc->sc_dwiic.sc_iba.iba_child_devices =
-		    acpi_enter_i2c_devs(sc->sc_acpinode);
+		    acpi_enter_i2c_devs(NULL, sc->sc_acpinode);
 	} else {
 		aprint_verbose_dev(self, "no matching ACPI node\n");
+	}
 	dwiic_attach(&sc->sc_dwiic);
 	config_found_ia(self, "i2cbus", &sc->sc_dwiic.sc_iba, iicbus_print);
 	pmf_device_register(self, dwiic_suspend, dwiic_resume);
 out:
 	return;
+}
 static bool
 dwiic_pci_power(struct dwiic_softc *dwsc, bool power)
+{
 	struct pci_dwiic_softc *sc = (void *)dwsc;
 	pcireg_t pmreg;
 	printf("status 0x%x\n", pci_conf_read(sc->sc_pc, sc->sc_ptag, PCI_COMMAND_STATUS_REG));
 	printf("reset 0x%x\n", lpss_read(sc, LPSS_RESET));
 	printf("rlo 0x%x\n", lpss_read(sc, LPSS_REMAP_LO));
 	printf("rho 0x%x\n", lpss_read(sc, LPSS_REMAP_HI));
 	if (!power)
 		lpss_write(sc, LPSS_CLKGATE, LPSS_CLKGATE_CTRL_OFF);
 	if (pci_get_capability(sc->sc_pc, sc->sc_ptag, PCI_CAP_PWRMGMT,
 	    &pmreg, NULL)) {
 		DPRINTF(("%s: power status 0x%x", device_xname(dwsc->sc_dev),
 		    pci_conf_read(sc->sc_pc, sc->sc_ptag, pmreg + PCI_PMCSR)));
 		pci_conf_write(sc->sc_pc, sc->sc_ptag, pmreg + PCI_PMCSR,
 		    power ? PCI_PMCSR_STATE_D0 : PCI_PMCSR_STATE_D3);
 		DELAY(10000); /* 10 milliseconds */
 		DPRINTF((" -> 0x%x\n",
 		    pci_conf_read(sc->sc_pc, sc->sc_ptag, pmreg + PCI_PMCSR)));
+	}
 	if (power) {
 		lpss_write(sc, LPSS_CLKGATE, LPSS_CLKGATE_CTRL_ON);
+	}
 	return true;
+}

 @@ -1,244 +1,249 @@
-/* $NetBSD: acpi_i2c.c,v 1.9 2021/01/25 12:15:32 jmcneill Exp $ */
+/* $NetBSD: acpi_i2c.c,v 1.10 2021/01/26 00:19:53 jmcneill Exp $ */
 /*-
  * Copyright (c) 2017 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Manuel Bouyer.
+ *
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: acpi_i2c.c,v 1.9 2021/01/25 12:15:32 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi_i2c.c,v 1.10 2021/01/26 00:19:53 jmcneill Exp $");
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_i2c.h>
 #include <dev/i2c/i2cvar.h>
 #define _COMPONENT	ACPI_BUS_COMPONENT
 ACPI_MODULE_NAME	("acpi_i2c")
 static void
 acpi_enter_i2c_hid(struct acpi_devnode *devnode, prop_dictionary_t dev)
+{
 	ACPI_OBJECT_LIST arg;
 	ACPI_OBJECT obj[4];
 	ACPI_OBJECT *osc;
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	/* 3cdff6f7-4267-4555-ad05-b30a3d8938de */
 	static uint8_t i2c_hid_guid[] = {
 xF7, 0xF6, 0xDF, 0x3C, 0x67, 0x42, 0x55, 0x45,
 xAD, 0x05, 0xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE,
 	};
 	arg.Count = 4;
 	arg.Pointer = obj;
 	obj[0].Type = ACPI_TYPE_BUFFER;
 	obj[0].Buffer.Length = sizeof(i2c_hid_guid);
 	obj[0].Buffer.Pointer = i2c_hid_guid;
 	/* rev */
 	obj[1].Type = ACPI_TYPE_INTEGER;
 	obj[1].Integer.Value = 1;
 	/* func */
 	obj[2].Type = ACPI_TYPE_INTEGER;
 	obj[2].Integer.Value = 1;
 	obj[3].Type = ACPI_TYPE_PACKAGE;
 	obj[3].Buffer.Length = 0;
 	buf.Pointer = NULL;
 	buf.Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 	rv = AcpiEvaluateObject(devnode->ad_handle, "_DSM", &arg, &buf);
 	if (ACPI_FAILURE(rv)) {
 		aprint_error("failed to evaluate _DSM for %s: %s\n",
 		    devnode->ad_name, AcpiFormatException(rv));
 		return;
+	}
 	osc = buf.Pointer;
 	if (osc->Type != ACPI_TYPE_INTEGER) {
 		aprint_error("bad _DSM return type %d for %s\n",
 		    osc->Type, devnode->ad_name);
 		return;
+	}
 	prop_dictionary_set_uint32(dev, "hid-descr-addr", osc->Integer.Value);
+}
 struct acpi_i2c_id {
 	const char *id;
 	const char *compat;
 	const int compatlen;
 	void (*parse)(struct acpi_devnode *, prop_dictionary_t);
 };
 static const struct acpi_i2c_id acpi_i2c_ids[] = {
+	{
 		.id = "PNP0C50",
 		.compat = "hid-over-i2c",
 		.compatlen = 13,
 		.parse = acpi_enter_i2c_hid
 	},
+	{
 		.id = "ACPI0C50",
 		.compat = "hid-over-i2c",
 		.compatlen = 13,
 		.parse = acpi_enter_i2c_hid
 	},
+	{
 		.id = "NXP0002",
 		.compat = "nxp,pca9547",
 		.compatlen = 12,
 		.parse = NULL
 	},
+	{
 		.id = NULL,
 		.compat = NULL,
 		.compatlen = 0,
 		.parse = NULL
+	}
 };
 static const struct acpi_i2c_id *
 acpi_i2c_search(const char *name)
+{
 	int i;
 	for (i = 0; acpi_i2c_ids[i].id != NULL; i++) {
 		if (strcmp(name, acpi_i2c_ids[i].id) == 0)
 			return &acpi_i2c_ids[i];
+	}
 	return NULL;
+}
 struct acpi_i2c_context {
 	uint16_t i2c_addr;
 };
 static ACPI_STATUS
 acpi_i2c_resource_parse_callback(ACPI_RESOURCE *res, void *context)
+{
 	struct acpi_i2c_context *i2cc = context;
 	switch (res->Type) {
 	case ACPI_RESOURCE_TYPE_END_TAG:
 		break;
 	case ACPI_RESOURCE_TYPE_SERIAL_BUS:
 		switch (res->Data.I2cSerialBus.Type) {
 		case ACPI_RESOURCE_SERIAL_TYPE_I2C:
 			i2cc->i2c_addr = res->Data.I2cSerialBus.SlaveAddress;
 			break;
+		}
 		break;
 	case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
 		break;
 	default:
 		printf("resource type 0x%x ignored\n", res->Type);
+	}
 	return_ACPI_STATUS(AE_OK);
+}
 static void
 acpi_enter_i2c_device(struct acpi_devnode *ad, prop_array_t array)
+{
 	prop_dictionary_t dev;
 	struct acpi_i2c_context i2cc;
 	ACPI_STATUS rv;
 	int cidi;
 	ACPI_PNP_DEVICE_ID_LIST *idlist;
 	const char *name;
 	static const struct acpi_i2c_id *i2c_id;
 	memset(&i2cc, 0, sizeof(i2cc));
 	rv = AcpiWalkResources(ad->ad_handle, "_CRS",
 	     acpi_i2c_resource_parse_callback, &i2cc);
 	if (ACPI_FAILURE(rv)) {
 		aprint_error("ACPI: unable to get resources "
 		   "for %s: %s\n", ad->ad_name,
 		   AcpiFormatException(rv));
 		return;
+	}
 	if (i2cc.i2c_addr == 0)
 		return;
 	dev = prop_dictionary_create();
 	if (dev == NULL) {
 		aprint_error("ignoring device %s (no memory)\n",
 		    ad->ad_name);
 		return;
+	}
 	if ((ad->ad_devinfo->Valid &  ACPI_VALID_HID) == 0)
 		name = ad->ad_name;
 	else
 		name = ad->ad_devinfo->HardwareId.String;
 	prop_dictionary_set_string(dev, "name", name);
 	prop_dictionary_set_uint32(dev, "addr", i2cc.i2c_addr);
 	prop_dictionary_set_uint64(dev, "cookie", (uintptr_t)ad->ad_handle);
 	prop_dictionary_set_uint32(dev, "cookietype", I2C_COOKIE_ACPI);
 	/* first search by name, then by CID */
 	i2c_id = acpi_i2c_search(name);
 	idlist = &ad->ad_devinfo->CompatibleIdList;
 	for (cidi = 0;
 	    cidi < idlist->Count && i2c_id == NULL;
 	    cidi++) {
 		i2c_id = acpi_i2c_search(idlist->Ids[cidi].String);
+	}
 	if (i2c_id != NULL) {
 		if (i2c_id->compat != NULL) {
 			prop_data_t data;
 			data = prop_data_create_copy(i2c_id->compat,
 			    i2c_id->compatlen);
 			prop_dictionary_set(dev, "compatible", data);
 			prop_object_release(data);
+		}
 		if (i2c_id->parse != NULL)
 			i2c_id->parse(ad, dev);
+	}
 	prop_array_add(array, dev);
 	prop_object_release(dev);
+}
 prop_array_t
-acpi_enter_i2c_devs(struct acpi_devnode *devnode)
+acpi_enter_i2c_devs(device_t dev, struct acpi_devnode *devnode)
+{
 	struct acpi_devnode *ad;
 	prop_array_t array = prop_array_create();
 	if (array == NULL)
 		return NULL;
 	SIMPLEQ_FOREACH(ad, &devnode->ad_child_head, ad_child_list) {
 		if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE)
 			continue;
 		if (!acpi_device_present(ad->ad_handle))
 			continue;
 		acpi_enter_i2c_device(ad, array);
+	}
 	if (dev != NULL) {
 		acpi_claim_childdevs(dev, devnode);
+	}
 	return array;
+}

 @@ -1,105 +1,107 @@
-/*	$NetBSD: acpi_util.h,v 1.9 2021/01/14 14:35:53 thorpej Exp $ */
+/*	$NetBSD: acpi_util.h,v 1.10 2021/01/26 00:19:53 jmcneill Exp $ */
 /*-
  * Copyright (c) 2003, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum of By Noon Software, 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 /*
  * Copyright 2001, 2003 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.
  */
 #ifndef _SYS_DEV_ACPI_ACPI_UTIL_H
 #define _SYS_DEV_ACPI_ACPI_UTIL_H
 ACPI_STATUS	acpi_eval_integer(ACPI_HANDLE, const char *, ACPI_INTEGER *);
 ACPI_STATUS	acpi_eval_set_integer(ACPI_HANDLE handle, const char *path,
 		    ACPI_INTEGER arg);
 ACPI_STATUS	acpi_eval_string(ACPI_HANDLE, const char *, char **);
 ACPI_STATUS	acpi_eval_struct(ACPI_HANDLE, const char *, ACPI_BUFFER *);
 ACPI_STATUS	acpi_eval_reference_handle(ACPI_OBJECT *, ACPI_HANDLE *);
 ACPI_STATUS	acpi_foreach_package_object(ACPI_OBJECT *,
 			ACPI_STATUS (*)(ACPI_OBJECT *, void *), void *);
 ACPI_STATUS	acpi_get(ACPI_HANDLE, ACPI_BUFFER *,
 			ACPI_STATUS (*)(ACPI_HANDLE, ACPI_BUFFER *));
 struct acpi_devnode *acpi_match_node(ACPI_HANDLE handle);
 void		     acpi_match_node_init(struct acpi_devnode *ad);
 const char	*acpi_name(ACPI_HANDLE);
 int		 acpi_match_hid(ACPI_DEVICE_INFO *, const char * const *);
 int		 acpi_match_class(ACPI_HANDLE, uint8_t, uint8_t, uint8_t);
 ACPI_HANDLE	 acpi_match_cpu_info(struct cpu_info *);
 struct cpu_info *acpi_match_cpu_handle(ACPI_HANDLE);
 char		*acpi_pack_compat_list(ACPI_DEVICE_INFO *, size_t *);
 ACPI_STATUS	 acpi_dsd_integer(ACPI_HANDLE, const char *, ACPI_INTEGER *);
 ACPI_STATUS	 acpi_dsd_string(ACPI_HANDLE, const char *, char **);
 ACPI_STATUS	 acpi_dsm(ACPI_HANDLE, uint8_t *, ACPI_INTEGER,
 			ACPI_INTEGER, const ACPI_OBJECT *, ACPI_OBJECT **);
 ACPI_STATUS	 acpi_dsm_typed(ACPI_HANDLE, uint8_t *, ACPI_INTEGER,
 			ACPI_INTEGER, const ACPI_OBJECT *,
 			ACPI_OBJECT_TYPE, ACPI_OBJECT **);
 ACPI_STATUS	 acpi_dsm_integer(ACPI_HANDLE, uint8_t *, ACPI_INTEGER,
 			ACPI_INTEGER, const ACPI_OBJECT *,
 			ACPI_INTEGER *);
 ACPI_STATUS	 acpi_claim_childdevs(device_t, struct acpi_devnode *);
 #endif	/* !_SYS_DEV_ACPI_ACPI_UTIL_H */

 @@ -1,866 +1,882 @@
-/*	$NetBSD: acpi_util.c,v 1.20 2021/01/14 14:35:53 thorpej Exp $ */
+/*	$NetBSD: acpi_util.c,v 1.21 2021/01/26 00:19:53 jmcneill Exp $ */
 /*-
  * Copyright (c) 2003, 2007, 2021 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum of By Noon Software, 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 /*
  * Copyright 2001, 2003 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: acpi_util.c,v 1.20 2021/01/14 14:35:53 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi_util.c,v 1.21 2021/01/26 00:19:53 jmcneill Exp $");
 #include <sys/param.h>
 #include <sys/kmem.h>
 #include <sys/cpu.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_intr.h>
 #include <machine/acpi_machdep.h>
 #define _COMPONENT	ACPI_BUS_COMPONENT
 ACPI_MODULE_NAME	("acpi_util")
 static void		acpi_clean_node(ACPI_HANDLE, void *);
 static const char * const acpicpu_ids[] = {
 	"ACPI0007",
 	NULL
 };
 /*
  * Evaluate an integer object.
  */
 ACPI_STATUS
 acpi_eval_integer(ACPI_HANDLE handle, const char *path, ACPI_INTEGER *valp)
+{
 	ACPI_OBJECT obj;
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	if (handle == NULL)
 		handle = ACPI_ROOT_OBJECT;
 	(void)memset(&obj, 0, sizeof(obj));
 	buf.Pointer = &obj;
 	buf.Length = sizeof(obj);
 	rv = AcpiEvaluateObject(handle, path, NULL, &buf);
 	if (ACPI_FAILURE(rv))
 		return rv;
 	/* Check that evaluation produced a return value. */
 	if (buf.Length == 0)
 		return AE_NULL_OBJECT;
 	if (obj.Type != ACPI_TYPE_INTEGER)
 		return AE_TYPE;
 	if (valp != NULL)
 		*valp = obj.Integer.Value;
 	return AE_OK;
+}
 /*
  * Evaluate an integer object with a single integer input parameter.
  */
 ACPI_STATUS
 acpi_eval_set_integer(ACPI_HANDLE handle, const char *path, ACPI_INTEGER val)
+{
 	ACPI_OBJECT_LIST arg;
 	ACPI_OBJECT obj;
 	if (handle == NULL)
 		handle = ACPI_ROOT_OBJECT;
 	obj.Type = ACPI_TYPE_INTEGER;
 	obj.Integer.Value = val;
 	arg.Count = 1;
 	arg.Pointer = &obj;
 	return AcpiEvaluateObject(handle, path, &arg, NULL);
+}
 /*
  * Evaluate a (Unicode) string object.
  */
 ACPI_STATUS
 acpi_eval_string(ACPI_HANDLE handle, const char *path, char **stringp)
+{
 	ACPI_OBJECT *obj;
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	rv = acpi_eval_struct(handle, path, &buf);
 	if (ACPI_FAILURE(rv))
 		return rv;
 	obj = buf.Pointer;
 	if (obj->Type != ACPI_TYPE_STRING) {
 		rv = AE_TYPE;
 		goto out;
+	}
 	if (obj->String.Length == 0) {
 		rv = AE_BAD_DATA;
 		goto out;
+	}
 	*stringp = ACPI_ALLOCATE(obj->String.Length + 1);
 	if (*stringp == NULL) {
 		rv = AE_NO_MEMORY;
 		goto out;
+	}
 	(void)memcpy(*stringp, obj->String.Pointer, obj->String.Length);
 	(*stringp)[obj->String.Length] = '\0';
 out:
 	ACPI_FREE(buf.Pointer);
 	return rv;
+}
 /*
  * Evaluate a structure. Caller must free buf.Pointer by ACPI_FREE().
  */
 ACPI_STATUS
 acpi_eval_struct(ACPI_HANDLE handle, const char *path, ACPI_BUFFER *buf)
+{
 	if (handle == NULL)
 		handle = ACPI_ROOT_OBJECT;
 	buf->Pointer = NULL;
 	buf->Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 	return AcpiEvaluateObject(handle, path, NULL, buf);
+}
 /*
  * Evaluate a reference handle from an element in a package.
  */
 ACPI_STATUS
 acpi_eval_reference_handle(ACPI_OBJECT *elm, ACPI_HANDLE *handle)
+{
 	if (elm == NULL || handle == NULL)
 		return AE_BAD_PARAMETER;
 	switch (elm->Type) {
 	case ACPI_TYPE_ANY:
 	case ACPI_TYPE_LOCAL_REFERENCE:
 		if (elm->Reference.Handle == NULL)
 			return AE_NULL_ENTRY;
 		*handle = elm->Reference.Handle;
 		return AE_OK;
 	case ACPI_TYPE_STRING:
 		return AcpiGetHandle(NULL, elm->String.Pointer, handle);
 	default:
 		return AE_TYPE;
+	}
+}
 /*
  * Iterate over all objects in a package, and pass them all
  * to a function. If the called function returns non-AE_OK,
  * the iteration is stopped and that value is returned.
  */
 ACPI_STATUS
 acpi_foreach_package_object(ACPI_OBJECT *pkg,
     ACPI_STATUS (*func)(ACPI_OBJECT *, void *), void *arg)
+{
 	ACPI_STATUS rv = AE_OK;
 	uint32_t i;
 	if (pkg == NULL)
 		return AE_BAD_PARAMETER;
 	if (pkg->Type != ACPI_TYPE_PACKAGE)
 		return AE_TYPE;
 	for (i = 0; i < pkg->Package.Count; i++) {
 		rv = (*func)(&pkg->Package.Elements[i], arg);
 		if (ACPI_FAILURE(rv))
 			break;
+	}
 	return rv;
+}
 /*
  * Fetch data info the specified (empty) ACPI buffer.
  * Caller must free buf.Pointer by ACPI_FREE().
  */
 ACPI_STATUS
 acpi_get(ACPI_HANDLE handle, ACPI_BUFFER *buf,
     ACPI_STATUS (*getit)(ACPI_HANDLE, ACPI_BUFFER *))
+{
 	buf->Pointer = NULL;
 	buf->Length = ACPI_ALLOCATE_LOCAL_BUFFER;
 	return (*getit)(handle, buf);
+}
 /*
  * Return a complete pathname from a handle.
+ *
  * Note that the function uses static data storage;
  * if the data is needed for future use, it should be
  * copied before any subsequent calls overwrite it.
  */
 const char *
 acpi_name(ACPI_HANDLE handle)
+{
 	static char name[80];
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	if (handle == NULL)
 		handle = ACPI_ROOT_OBJECT;
 	buf.Pointer = name;
 	buf.Length = sizeof(name);
 	rv = AcpiGetName(handle, ACPI_FULL_PATHNAME, &buf);
 	if (ACPI_FAILURE(rv))
 		return "UNKNOWN";
 	return name;
+}
 /*
  * Pack _HID and _CID ID strings into an OpenFirmware-like
  * string list.
  */
 char *
 acpi_pack_compat_list(ACPI_DEVICE_INFO *ad, size_t *sizep)
+{
 	KASSERT(sizep != NULL);
 	char *strlist, *cp;
 	size_t len = 0;
 	uint32_t i;
 	/*
 	 * First calculate the total size required.
 	 * N.B. PNP Device ID length includes terminating NUL.
 	 */
 	if ((ad->Valid & ACPI_VALID_HID) != 0) {
 		len += ad->HardwareId.Length;
+	}
 	if ((ad->Valid & ACPI_VALID_CID) != 0) {
 		for (i = 0; i < ad->CompatibleIdList.Count; i++) {
 			len += ad->CompatibleIdList.Ids[i].Length;
+		}
+	}
 	*sizep = len;
 	if (len == 0) {
 		return NULL;
+	}
 	cp = strlist = kmem_alloc(len, KM_SLEEP);
 	if ((ad->Valid & ACPI_VALID_HID) != 0) {
 		memcpy(cp, ad->HardwareId.String, ad->HardwareId.Length);
 		cp += ad->HardwareId.Length;
+	}
 	if ((ad->Valid & ACPI_VALID_CID) != 0) {
 		for (i = 0; i < ad->CompatibleIdList.Count; i++) {
 			memcpy(cp, ad->CompatibleIdList.Ids[i].String,
 			    ad->CompatibleIdList.Ids[i].Length);
 			cp += ad->CompatibleIdList.Ids[i].Length;
+		}
+	}
 	KASSERT((size_t)(cp - strlist) == len);
 	return strlist;
+}
 /*
  * Match given IDs against _HID and _CIDs.
  */
 int
 acpi_match_hid(ACPI_DEVICE_INFO *ad, const char * const *ids)
+{
 	uint32_t i, n;
 	char *id;
 	while (*ids) {
 		if ((ad->Valid & ACPI_VALID_HID) != 0) {
 			if (pmatch(ad->HardwareId.String, *ids, NULL) == 2)
 				return 1;
+		}
 		if ((ad->Valid & ACPI_VALID_CID) != 0) {
 			n = ad->CompatibleIdList.Count;
 			for (i = 0; i < n; i++) {
 				id = ad->CompatibleIdList.Ids[i].String;
 				if (pmatch(id, *ids, NULL) == 2)
 					return 1;
+			}
+		}
 		ids++;
+	}
 	return 0;
+}
 /*
  * Match a PCI-defined bass-class, sub-class, and programming interface
  * against a handle's _CLS object.
  */
 int
 acpi_match_class(ACPI_HANDLE handle, uint8_t pci_class, uint8_t pci_subclass,
     uint8_t pci_interface)
+{
 	ACPI_BUFFER buf;
 	ACPI_OBJECT *obj;
 	ACPI_STATUS rv;
 	int match = 0;
 	rv = acpi_eval_struct(handle, "_CLS", &buf);
 	if (ACPI_FAILURE(rv))
 		goto done;
 	obj = buf.Pointer;
 	if (obj->Type != ACPI_TYPE_PACKAGE)
 		goto done;
 	if (obj->Package.Count != 3)
 		goto done;
 	if (obj->Package.Elements[0].Type != ACPI_TYPE_INTEGER ||
 	    obj->Package.Elements[1].Type != ACPI_TYPE_INTEGER ||
 	    obj->Package.Elements[2].Type != ACPI_TYPE_INTEGER)
 		goto done;
 	match = obj->Package.Elements[0].Integer.Value == pci_class &&
 		obj->Package.Elements[1].Integer.Value == pci_subclass &&
 		obj->Package.Elements[2].Integer.Value == pci_interface;
 done:
 	if (buf.Pointer)
 		ACPI_FREE(buf.Pointer);
 	return match;
+}
 /*
  * Match a device node from a handle.
  */
 struct acpi_devnode *
 acpi_match_node(ACPI_HANDLE handle)
+{
 	struct acpi_devnode *ad;
 	ACPI_STATUS rv;
 	if (handle == NULL)
 		return NULL;
 	rv = AcpiGetData(handle, acpi_clean_node, (void **)&ad);
 	if (ACPI_FAILURE(rv))
 		return NULL;
 	return ad;
+}
 /*
  * Permanently associate a device node with a handle.
  */
 void
 acpi_match_node_init(struct acpi_devnode *ad)
+{
 	(void)AcpiAttachData(ad->ad_handle, acpi_clean_node, ad);
+}
 static void
 acpi_clean_node(ACPI_HANDLE handle, void *aux)
+{
 	/* Nothing. */
+}
 /*
  * Match a handle from a cpu_info. Returns NULL on failure.
+ *
  * Note that acpi_match_node() can be used if the device node
  * is also required.
  */
 ACPI_HANDLE
 acpi_match_cpu_info(struct cpu_info *ci)
+{
 	struct acpi_softc *sc = acpi_softc;
 	struct acpi_devnode *ad;
 	ACPI_INTEGER val;
 	ACPI_OBJECT *obj;
 	ACPI_BUFFER buf;
 	ACPI_HANDLE hdl;
 	ACPI_STATUS rv;
 	if (sc == NULL || acpi_active == 0)
 		return NULL;
 	/*
 	 * CPUs are declared in the ACPI namespace
 	 * either as a Processor() or as a Device().
 	 * In both cases the MADT entries are used
 	 * for the match (see ACPI 4.0, section 8.4).
 	 */
 	SIMPLEQ_FOREACH(ad, &sc->ad_head, ad_list) {
 		hdl = ad->ad_handle;
 		switch (ad->ad_type) {
 		case ACPI_TYPE_DEVICE:
 			if (acpi_match_hid(ad->ad_devinfo, acpicpu_ids) == 0)
 				break;
 			rv = acpi_eval_integer(hdl, "_UID", &val);
 			if (ACPI_SUCCESS(rv) && val == ci->ci_acpiid)
 				return hdl;
 			break;
 		case ACPI_TYPE_PROCESSOR:
 			rv = acpi_eval_struct(hdl, NULL, &buf);
 			if (ACPI_FAILURE(rv))
 				break;
 			obj = buf.Pointer;
 			if (obj->Processor.ProcId == ci->ci_acpiid) {
 				ACPI_FREE(buf.Pointer);
 				return hdl;
+			}
 			ACPI_FREE(buf.Pointer);
 			break;
+		}
+	}
 	return NULL;
+}
 /*
  * Match a CPU from a handle. Returns NULL on failure.
  */
 struct cpu_info *
 acpi_match_cpu_handle(ACPI_HANDLE hdl)
+{
 	struct cpu_info *ci;
 	ACPI_DEVICE_INFO *di;
 	CPU_INFO_ITERATOR cii;
 	ACPI_INTEGER val;
 	ACPI_OBJECT *obj;
 	ACPI_BUFFER buf;
 	ACPI_STATUS rv;
 	ci = NULL;
 	di = NULL;
 	buf.Pointer = NULL;
 	rv = AcpiGetObjectInfo(hdl, &di);
 	if (ACPI_FAILURE(rv))
 		return NULL;
 	switch (di->Type) {
 	case ACPI_TYPE_DEVICE:
 		if (acpi_match_hid(di, acpicpu_ids) == 0)
 			goto out;
 		rv = acpi_eval_integer(hdl, "_UID", &val);
 		if (ACPI_FAILURE(rv))
 			goto out;
 		break;
 	case ACPI_TYPE_PROCESSOR:
 		rv = acpi_eval_struct(hdl, NULL, &buf);
 		if (ACPI_FAILURE(rv))
 			goto out;
 		obj = buf.Pointer;
 		val = obj->Processor.ProcId;
 		break;
 	default:
 		goto out;
+	}
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		if (ci->ci_acpiid == val)
 			goto out;
+	}
 	ci = NULL;
 out:
 	if (di != NULL)
 		ACPI_FREE(di);
 	if (buf.Pointer != NULL)
 		ACPI_FREE(buf.Pointer);
 	return ci;
+}
 struct acpi_irq_handler {
 	uint32_t aih_irq;
 	void *aih_ih;
 };
 void *
 acpi_intr_establish(device_t dev, uint64_t c, int ipl, bool mpsafe,
     int (*intr)(void *), void *iarg, const char *xname)
+{
 	ACPI_STATUS rv;
 	ACPI_HANDLE hdl = (void *)(uintptr_t)c;
 	struct acpi_resources res;
 	struct acpi_irq *irq;
 	void *aih = NULL;
 	rv = acpi_resource_parse(dev, hdl, "_CRS", &res,
 	    &acpi_resource_parse_ops_quiet);
 	if (ACPI_FAILURE(rv))
 		return NULL;
 	irq = acpi_res_irq(&res, 0);
 	if (irq == NULL)
 		goto end;
 	aih = acpi_intr_establish_irq(dev, irq, ipl, mpsafe,
 	    intr, iarg, xname);
 end:
 	acpi_resource_cleanup(&res);
 	return aih;
+}
 void *
 acpi_intr_establish_irq(device_t dev, struct acpi_irq *irq, int ipl,
     bool mpsafe, int (*intr)(void *), void *iarg, const char *xname)
+{
 	struct acpi_irq_handler *aih;
 	void *ih;
 	const int type = (irq->ar_type == ACPI_EDGE_SENSITIVE) ? IST_EDGE : IST_LEVEL;
 	ih = acpi_md_intr_establish(irq->ar_irq, ipl, type, intr, iarg, mpsafe, xname);
 	if (ih == NULL)
 		return NULL;
 	aih = kmem_alloc(sizeof(struct acpi_irq_handler), KM_SLEEP);
 	aih->aih_irq = irq->ar_irq;
 	aih->aih_ih = ih;
 	return aih;
+}
 void
 acpi_intr_mask(void *c)
+{
 	struct acpi_irq_handler * const aih = c;
 	acpi_md_intr_mask(aih->aih_ih);
+}
 void
 acpi_intr_unmask(void *c)
+{
 	struct acpi_irq_handler * const aih = c;
 	acpi_md_intr_unmask(aih->aih_ih);
+}
 void
 acpi_intr_disestablish(void *c)
+{
 	struct acpi_irq_handler *aih = c;
 	acpi_md_intr_disestablish(aih->aih_ih);
 	kmem_free(aih, sizeof(struct acpi_irq_handler));
+}
 const char *
 acpi_intr_string(void *c, char *buf, size_t size)
+{
 	struct acpi_irq_handler *aih = c;
 	intr_handle_t ih = aih->aih_irq;
 	return intr_string(ih, buf, size);
+}
 /*
  * Device-Specific Data (_DSD) support
  */
 static UINT8 acpi_dsd_uuid[ACPI_UUID_LENGTH] = {
 x14, 0xd8, 0xff, 0xda, 0xba, 0x6e, 0x8c, 0x4d,
 x8a, 0x91, 0xbc, 0x9b, 0xbf, 0x4a, 0xa3, 0x01
 };
 static ACPI_STATUS
 acpi_dsd_property(ACPI_HANDLE handle, const char *prop, ACPI_BUFFER *pbuf, ACPI_OBJECT_TYPE type, ACPI_OBJECT **ret)
+{
 	ACPI_OBJECT *obj, *uuid, *props, *pobj, *propkey, *propval;
 	ACPI_STATUS rv;
 	int n;
 	rv = AcpiEvaluateObjectTyped(handle, "_DSD", NULL, pbuf, ACPI_TYPE_PACKAGE);
 	if (ACPI_FAILURE(rv))
 		return rv;
 	props = NULL;
 	obj = (ACPI_OBJECT *)pbuf->Pointer;
 	for (n = 0; (n + 1) < obj->Package.Count; n += 2) {
 		uuid = &obj->Package.Elements[n];
 		if (uuid->Buffer.Length == ACPI_UUID_LENGTH &&
 		    memcmp(uuid->Buffer.Pointer, acpi_dsd_uuid, ACPI_UUID_LENGTH) == 0) {
 			props = &obj->Package.Elements[n + 1];
 			break;
+		}
+	}
 	if (props == NULL)
 		return AE_NOT_FOUND;
 	for (n = 0; n < props->Package.Count; n++) {
 		pobj = &props->Package.Elements[n];
 		if (pobj->Type != ACPI_TYPE_PACKAGE || pobj->Package.Count != 2)
 			continue;
 		propkey = (ACPI_OBJECT *)&pobj->Package.Elements[0];
 		propval = (ACPI_OBJECT *)&pobj->Package.Elements[1];
 		if (propkey->Type != ACPI_TYPE_STRING)
 			continue;
 		if (strcmp(propkey->String.Pointer, prop) != 0)
 			continue;
 		if (propval->Type != type) {
 			return AE_TYPE;
 		} else {
 			*ret = propval;
 			return AE_OK;
+		}
 		break;
+	}
 	return AE_NOT_FOUND;
+}
 ACPI_STATUS
 acpi_dsd_integer(ACPI_HANDLE handle, const char *prop, ACPI_INTEGER *val)
+{
 	ACPI_OBJECT *propval;
 	ACPI_STATUS rv;
 	ACPI_BUFFER buf;
 	buf.Pointer = NULL;
 	buf.Length = ACPI_ALLOCATE_BUFFER;
 	rv = acpi_dsd_property(handle, prop, &buf, ACPI_TYPE_INTEGER, &propval);
 	if (ACPI_SUCCESS(rv))
 		*val = propval->Integer.Value;
 	if (buf.Pointer != NULL)
 		ACPI_FREE(buf.Pointer);
 	return rv;
+}
 ACPI_STATUS
 acpi_dsd_string(ACPI_HANDLE handle, const char *prop, char **val)
+{
 	ACPI_OBJECT *propval;
 	ACPI_STATUS rv;
 	ACPI_BUFFER buf;
 	buf.Pointer = NULL;
 	buf.Length = ACPI_ALLOCATE_BUFFER;
 	rv = acpi_dsd_property(handle, prop, &buf, ACPI_TYPE_STRING, &propval);
 	if (ACPI_SUCCESS(rv))
 		*val = kmem_strdup(propval->String.Pointer, KM_SLEEP);
 	if (buf.Pointer != NULL)
 		ACPI_FREE(buf.Pointer);
 	return rv;
+}
 /*
  * Device Specific Method (_DSM) support
  */
 ACPI_STATUS
 acpi_dsm_typed(ACPI_HANDLE handle, uint8_t *uuid, ACPI_INTEGER rev,
     ACPI_INTEGER func, const ACPI_OBJECT *arg3, ACPI_OBJECT_TYPE return_type,
     ACPI_OBJECT **return_obj)
+{
 	ACPI_OBJECT_LIST arg;
 	ACPI_OBJECT obj[4];
 	ACPI_BUFFER buf;
 	ACPI_STATUS status;
 	arg.Count = 4;
 	arg.Pointer = obj;
 	obj[0].Type = ACPI_TYPE_BUFFER;
 	obj[0].Buffer.Length = ACPI_UUID_LENGTH;
 	obj[0].Buffer.Pointer = uuid;
 	obj[1].Type = ACPI_TYPE_INTEGER;
 	obj[1].Integer.Value = rev;
 	obj[2].Type = ACPI_TYPE_INTEGER;
 	obj[2].Integer.Value = func;
 	if (arg3 != NULL) {
 		obj[3] = *arg3;
 	} else {
 		obj[3].Type = ACPI_TYPE_PACKAGE;
 		obj[3].Package.Count = 0;
 		obj[3].Package.Elements = NULL;
+	}
 	buf.Pointer = NULL;
 	buf.Length = ACPI_ALLOCATE_BUFFER;
 	if (return_obj == NULL && return_type == ACPI_TYPE_ANY) {
 		status = AcpiEvaluateObject(handle, "_DSM", &arg, NULL);
 	} else {
 		*return_obj = NULL;
 		status = AcpiEvaluateObjectTyped(handle, "_DSM", &arg, &buf,
 		    return_type);
+	}
 	if (ACPI_FAILURE(status)) {
 		return status;
+	}
 	if (return_obj != NULL) {
 		*return_obj = buf.Pointer;
 	} else if (buf.Pointer != NULL) {
 		ACPI_FREE(buf.Pointer);
+	}
 	return AE_OK;
+}
 ACPI_STATUS
 acpi_dsm_integer(ACPI_HANDLE handle, uint8_t *uuid, ACPI_INTEGER rev,
     ACPI_INTEGER func, const ACPI_OBJECT *arg3, ACPI_INTEGER *ret)
+{
 	ACPI_OBJECT *obj;
 	ACPI_STATUS status;
 	status = acpi_dsm_typed(handle, uuid, rev, func, arg3,
 	    ACPI_TYPE_INTEGER, &obj);
 	if (ACPI_FAILURE(status)) {
 		return status;
+	}
 	*ret = obj->Integer.Value;
 	ACPI_FREE(obj);
 	return AE_OK;
+}
 ACPI_STATUS
 acpi_dsm(ACPI_HANDLE handle, uint8_t *uuid, ACPI_INTEGER rev,
     ACPI_INTEGER func, const ACPI_OBJECT *arg3, ACPI_OBJECT **return_obj)
+{
 	return acpi_dsm_typed(handle, uuid, rev, func, arg3, ACPI_TYPE_ANY,
 	    return_obj);
+}
 ACPI_STATUS
 acpi_claim_childdevs(device_t dev, struct acpi_devnode *devnode)
+{
 	struct acpi_devnode *ad;
 	SIMPLEQ_FOREACH(ad, &devnode->ad_child_head, ad_child_list) {
 		if (ad->ad_device != NULL)
 			continue;
 		aprint_debug(dev, "claiming %s\n", acpi_name(ad->ad_handle));
 		ad->ad_device = dev;
 		acpi_claim_childdevs(dev, ad);
+	}
 	return AE_OK;
+}

 @@ -1,182 +1,182 @@
-/* $NetBSD: dwiic_acpi.c,v 1.5 2021/01/24 16:33:48 jmcneill Exp $ */
+/* $NetBSD: dwiic_acpi.c,v 1.6 2021/01/26 00:19:53 jmcneill Exp $ */
 /*-
  * Copyright (c) 2018 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jared McNeill <jmcneill@invisible.ca>.
+ *
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: dwiic_acpi.c,v 1.5 2021/01/24 16:33:48 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: dwiic_acpi.c,v 1.6 2021/01/26 00:19:53 jmcneill Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_intr.h>
 #include <dev/acpi/acpi_i2c.h>
 #include <dev/ic/dwiic_var.h>
 struct dwiic_acpi_param {
 	uint16_t hcnt;
 	uint16_t lcnt;
 	uint32_t ht;
 };
 static int	dwiic_acpi_match(device_t, cfdata_t, void *);
 static void	dwiic_acpi_attach(device_t, device_t, void *);
 static void	dwiic_acpi_parse_param(struct dwiic_softc *, ACPI_HANDLE,
 					  const char *, struct dwiic_acpi_param *);
 static void	dwiic_acpi_configure(struct dwiic_softc *, ACPI_HANDLE);
 CFATTACH_DECL_NEW(dwiic_acpi, sizeof(struct dwiic_softc), dwiic_acpi_match, dwiic_acpi_attach, NULL, NULL);
 static const char * const compatible[] = {
 	"AMD0010",	/* AMD FCH */
 	"AMDI0010",	/* AMD FCH */
 	"AMDI0510",	/* AMD Seattle */
 	"APMC0D0F",	/* Ampere eMAG */
 	NULL
 };
 static int
 dwiic_acpi_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct acpi_attach_args *aa = aux;
 	if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
 		return 0;
 	return acpi_match_hid(aa->aa_node->ad_devinfo, compatible);
+}
 static void
 dwiic_acpi_attach(device_t parent, device_t self, void *aux)
+{
 	struct dwiic_softc * const sc = device_private(self);
 	struct acpi_attach_args *aa = aux;
 	struct acpi_resources res;
 	struct acpi_mem *mem;
 	struct acpi_irq *irq;
 	ACPI_STATUS rv;
 	int error;
 	void *ih;
 	sc->sc_dev = self;
 	sc->sc_type = dwiic_type_generic;
 	sc->sc_iot = aa->aa_memt;
 	rv = acpi_resource_parse(sc->sc_dev, aa->aa_node->ad_handle, "_CRS",
 	    &res, &acpi_resource_parse_ops_default);
 	if (ACPI_FAILURE(rv))
 		return;
 	mem = acpi_res_mem(&res, 0);
 	if (mem == NULL) {
 		aprint_error_dev(self, "couldn't find mem resource\n");
 		goto done;
+	}
 	irq = acpi_res_irq(&res, 0);
 	if (irq == NULL) {
 		aprint_error_dev(self, "couldn't find irq resource\n");
 		goto done;
+	}
 	error = bus_space_map(sc->sc_iot, mem->ar_base, mem->ar_length, 0, &sc->sc_ioh);
 	if (error) {
 		aprint_error_dev(self, "couldn't map registers\n");
 		return;
+	}
 	ih = acpi_intr_establish(self,
 	    (uint64_t)(uintptr_t)aa->aa_node->ad_handle,
 	    IPL_VM, true, dwiic_intr, sc, device_xname(self));
 	if (ih == NULL) {
 		aprint_error_dev(self, "couldn't install interrupt handler\n");
 		bus_space_unmap(sc->sc_iot, sc->sc_ioh, mem->ar_length);
 		goto done;
+	}
 	dwiic_acpi_configure(sc, aa->aa_node->ad_handle);
-	sc->sc_iba.iba_child_devices = acpi_enter_i2c_devs(aa->aa_node);
+	sc->sc_iba.iba_child_devices = acpi_enter_i2c_devs(self, aa->aa_node);
 	dwiic_attach(sc);
 	config_found_ia(self, "i2cbus", &sc->sc_iba, iicbus_print);
 	pmf_device_register(self, dwiic_suspend, dwiic_resume);
 done:
 	acpi_resource_cleanup(&res);
+}
 static void
 dwiic_acpi_parse_param(struct dwiic_softc *sc, ACPI_HANDLE handle, const char *path,
     struct dwiic_acpi_param *param)
+{
 	ACPI_BUFFER buf;
 	ACPI_OBJECT *obj;
 	memset(param, 0, sizeof(*param));
 	if (ACPI_FAILURE(acpi_eval_struct(handle, path, &buf)))
 		return;
 	obj = buf.Pointer;
 	if (obj->Type != ACPI_TYPE_PACKAGE || obj->Package.Count != 3)
 		goto done;
 	param->hcnt = (uint16_t)obj->Package.Elements[0].Integer.Value;
 	param->lcnt = (uint16_t)obj->Package.Elements[1].Integer.Value;
 	param->ht = (uint32_t)obj->Package.Elements[2].Integer.Value;
 done:
 	ACPI_FREE(buf.Pointer);
+}
 static void
 dwiic_acpi_configure(struct dwiic_softc *sc, ACPI_HANDLE handle)
+{
 	struct dwiic_acpi_param sscn, fmcn;
 	dwiic_acpi_parse_param(sc, handle, "SSCN", &sscn);
 	sc->ss_hcnt = sscn.hcnt;
 	sc->ss_lcnt = sscn.lcnt;
 	dwiic_acpi_parse_param(sc, handle, "FMCN", &fmcn);
 	sc->fs_hcnt = fmcn.hcnt;
 	sc->fs_lcnt = fmcn.lcnt;
 	/* XXX */
 	sc->sda_hold_time = fmcn.ht;
+}

 @@ -1,183 +1,183 @@
-/* $NetBSD: nxpiic_acpi.c,v 1.2 2021/01/25 12:09:58 jmcneill Exp $ */
+/* $NetBSD: nxpiic_acpi.c,v 1.3 2021/01/26 00:19:53 jmcneill Exp $ */
 /*-
  * Copyright (c) 2021 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jared McNeill <jmcneill@invisible.ca>.
+ *
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: nxpiic_acpi.c,v 1.2 2021/01/25 12:09:58 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: nxpiic_acpi.c,v 1.3 2021/01/26 00:19:53 jmcneill Exp $");
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_intr.h>
 #include <dev/acpi/acpi_i2c.h>
 #include <dev/i2c/motoi2cvar.h>
 #include <dev/i2c/motoi2creg.h>
 #define	NXPIIC_SPEED_STD	100000
 static const struct clk_div {
 	int scl_div;
 	uint8_t ibc;
 } nxpiic_clk_div[] = {
 	{ 20, 0x00 },	{ 22, 0x01 },	{ 24, 0x02 },	{ 26, 0x03 },
 	{ 28, 0x04 },	{ 30, 0x05 },	{ 32, 0x09 },	{ 34, 0x06 },
 	{ 36, 0x0a },	{ 40, 0x07 },	{ 44, 0x0c },	{ 48, 0x0d },
 	{ 52, 0x43 },	{ 56, 0x0e },	{ 60, 0x45 },	{ 64, 0x12 },
 	{ 68, 0x0f },	{ 72, 0x13 },	{ 80, 0x14 },	{ 88, 0x15 },
 	{ 96, 0x19 },	{ 104, 0x16 },	{ 112, 0x1a },	{ 128, 0x17 },
 	{ 136, 0x4f },	{ 144, 0x1c },	{ 160, 0x1d },	{ 176, 0x55 },
 	{ 192, 0x1e },	{ 208, 0x56 },	{ 224, 0x22 },	{ 228, 0x24 },
 	{ 240, 0x1f },	{ 256, 0x23 },	{ 288, 0x5c },	{ 320, 0x25 },
 	{ 384, 0x26 },	{ 448, 0x2a },	{ 480, 0x27 },	{ 512, 0x2b },
 	{ 576, 0x2c },	{ 640, 0x2d },	{ 768, 0x31 },	{ 896, 0x32 },
 	{ 960, 0x2f },	{ 1024, 0x33 },	{ 1152, 0x34 },	{ 1280, 0x35 },
 	{ 1536, 0x36 },	{ 1792, 0x3a },	{ 1920, 0x37 },	{ 2048, 0x3b },
 	{ 2304, 0x3c },	{ 2560, 0x3d },	{ 3072, 0x3e },	{ 3584, 0x7a },
 	{ 3840, 0x3f },	{ 4096, 0x7B },	{ 5120, 0x7d },	{ 6144, 0x7e },
 };
 struct nxpiic_softc {
 	device_t		sc_dev;
 	struct motoi2c_softc	sc_motoi2c;
 };
 static int	nxpiic_acpi_match(device_t, cfdata_t, void *);
 static void	nxpiic_acpi_attach(device_t, device_t, void *);
 static uint8_t	nxpiic_acpi_iord(struct motoi2c_softc *, bus_size_t);
 static void	nxpiic_acpi_iowr(struct motoi2c_softc *, bus_size_t, uint8_t);
 CFATTACH_DECL_NEW(nxpiic_acpi, sizeof(struct nxpiic_softc),
     nxpiic_acpi_match, nxpiic_acpi_attach, NULL, NULL);
 static const char * const compatible[] = {
 	"NXP0001",
 	NULL
 };
 static int
 nxpiic_acpi_match(device_t parent, cfdata_t cf, void *aux)
+{
 	struct acpi_attach_args *aa = aux;
 	if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
 		return 0;
 	return acpi_match_hid(aa->aa_node->ad_devinfo, compatible);
+}
 static void
 nxpiic_acpi_attach(device_t parent, device_t self, void *aux)
+{
 	struct nxpiic_softc * const sc = device_private(self);
 	struct motoi2c_softc * const msc = &sc->sc_motoi2c;
 	struct motoi2c_settings settings;
 	struct acpi_attach_args *aa = aux;
 	struct acpi_resources res;
 	struct acpi_mem *mem;
 	ACPI_INTEGER clock_freq;
 	ACPI_STATUS rv;
 	int error, n;
 	sc->sc_dev = self;
 	msc->sc_iot = aa->aa_memt;
 	rv = acpi_resource_parse(sc->sc_dev, aa->aa_node->ad_handle, "_CRS",
 	    &res, &acpi_resource_parse_ops_default);
 	if (ACPI_FAILURE(rv))
 		return;
 	mem = acpi_res_mem(&res, 0);
 	if (mem == NULL) {
 		aprint_error_dev(self, "couldn't find mem resource\n");
 		goto done;
+	}
 	rv = acpi_dsd_integer(aa->aa_node->ad_handle, "clock-frequency",
 	    &clock_freq);
 	if (ACPI_FAILURE(rv) || clock_freq == 0) {
 		aprint_error_dev(self, "couldn't get clock frequency\n");
 		goto done;
+	}
 	aprint_debug_dev(self, "bus clock %u Hz\n", (u_int)clock_freq);
 	error = bus_space_map(msc->sc_iot, mem->ar_base, mem->ar_length, 0,
 	    &msc->sc_ioh);
 	if (error) {
 		aprint_error_dev(self, "couldn't map registers\n");
 		return;
+	}
 	settings.i2c_adr = MOTOI2C_ADR_DEFAULT;
 	settings.i2c_dfsrr = MOTOI2C_DFSRR_DEFAULT;
 	for (n = 0; n < __arraycount(nxpiic_clk_div) - 1; n++) {
 		if (clock_freq / nxpiic_clk_div[n].scl_div < NXPIIC_SPEED_STD)
 			break;
+	}
 	settings.i2c_fdr = nxpiic_clk_div[n].ibc;
 	msc->sc_flags |= MOTOI2C_F_ENABLE_INV | MOTOI2C_F_STATUS_W1C;
 	msc->sc_iord = nxpiic_acpi_iord;
 	msc->sc_iowr = nxpiic_acpi_iowr;
-	msc->sc_child_devices = acpi_enter_i2c_devs(aa->aa_node);
+	msc->sc_child_devices = acpi_enter_i2c_devs(self, aa->aa_node);
 	motoi2c_attach_common(self, msc, &settings);
 done:
 	acpi_resource_cleanup(&res);
+}
 static uint8_t
 nxpiic_acpi_iord(struct motoi2c_softc *msc, bus_size_t off)
+{
 	KASSERT((off & 3) == 0);
 	if (off >= I2CDFSRR)
 		return 0;
 	return bus_space_read_1(msc->sc_iot, msc->sc_ioh, off >> 2);
+}
 static void
 nxpiic_acpi_iowr(struct motoi2c_softc *msc, bus_size_t off, uint8_t val)
+{
 	KASSERT((off & 3) == 0);
 	if (off >= I2CDFSRR)
 		return;
 	bus_space_write_1(msc->sc_iot, msc->sc_ioh, off >> 2, val);
+}

 @@ -1,316 +1,316 @@
-/*	$NetBSD: i2cmux.c,v 1.3 2021/01/25 12:18:18 jmcneill Exp $	*/
+/*	$NetBSD: i2cmux.c,v 1.4 2021/01/26 00:19:53 jmcneill Exp $	*/
 /*-
  * Copyright (c) 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe.
+ *
  * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 #if defined(__i386__) || defined(__amd64__) || defined(__aarch64__)
 #include "acpica.h"
 #endif
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: i2cmux.c,v 1.3 2021/01/25 12:18:18 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: i2cmux.c,v 1.4 2021/01/26 00:19:53 jmcneill Exp $");
 #include <sys/types.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <dev/fdt/fdtvar.h>
 #include <dev/i2c/i2cvar.h>
 #include <dev/i2c/i2cmuxvar.h>
 #if NACPICA > 0
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_i2c.h>
 #endif
 /*
  * i2c mux
+ *
  * This works by interposing a set of virtual controllers behind the real
  * i2c controller.  We provide our own acquire and release functions that
  * perform the following tasks:
+ *
  *	acquire -> acquire parent controller, program mux
+ *
  *	release -> idle mux, release parent controller
+ *
  * All of the actual I/O operations are transparently passed through.
+ *
  * N.B. the locking order; the generic I2C layer has already acquired
  * our virtual controller's mutex before calling our acquire function,
  * and we will then acquire the real controller's mutex when we acquire
  * the bus, so the order is:
+ *
  *	mux virtual controller -> parent controller
+ *
  * These are common routines used by various i2c mux controller
  * implementations (gpio, pin mux, i2c device, etc.).
  */
 /*****************************************************************************/
 static int
 iicmux_acquire_bus(void * const v, int const flags)
+{
 	struct iicmux_bus * const bus = v;
 	struct iicmux_softc * const sc = bus->mux;
 	int error;
 	error = iic_acquire_bus(sc->sc_i2c_parent, flags);
 	if (error) {
 		return error;
+	}
 	error = sc->sc_config->acquire_bus(bus, flags);
 	if (error) {
 		iic_release_bus(sc->sc_i2c_parent, flags);
+	}
 	return error;
+}
 static void
 iicmux_release_bus(void * const v, int const flags)
+{
 	struct iicmux_bus * const bus = v;
 	struct iicmux_softc * const sc = bus->mux;
 	sc->sc_config->release_bus(bus, flags);
 	iic_release_bus(sc->sc_i2c_parent, flags);
+}
 static int
 iicmux_exec(void * const v, i2c_op_t const op, i2c_addr_t const addr,
     const void * const cmdbuf, size_t const cmdlen, void * const databuf,
     size_t const datalen, int const flags)
+{
 	struct iicmux_bus * const bus = v;
 	struct iicmux_softc * const sc = bus->mux;
 	return iic_exec(sc->sc_i2c_parent, op, addr, cmdbuf, cmdlen,
 			databuf, datalen, flags);
+}
 /*****************************************************************************/
 static int
 iicmux_count_children(struct iicmux_softc * const sc)
+{
 	char name[32];
 	int child, count;
  restart:
 	for (child = OF_child(sc->sc_i2c_mux_phandle), count = 0; child;
 	     child = OF_peer(child)) {
 		if (OF_getprop(child, "name", name, sizeof(name)) <= 0) {
 			continue;
+		}
 		if (strcmp(name, "i2c-mux") == 0) {
 			/*
 			 * The node we encountered is the acutal parent
 			 * of the i2c bus children.  Stash its phandle
 			 * and restart the enumeration.
 			 */
 			sc->sc_i2c_mux_phandle = child;
 			goto restart;
+		}
 		count++;
+	}
 	return count;
+}
 /* XXX iicbus_print() should be able to do this. */
 static int
 iicmux_print(void * const aux, const char * const pnp)
+{
 	i2c_tag_t const tag = aux;
 	struct iicmux_bus * const bus = tag->ic_cookie;
 	int rv;
 	rv = iicbus_print(aux, pnp);
 	aprint_normal(" bus %d", bus->busidx);
 	return rv;
+}
 static void
 iicmux_attach_bus(struct iicmux_softc * const sc,
     uintptr_t const handle, enum i2c_cookie_type handletype, int const busidx)
+{
 	struct iicmux_bus * const bus = &sc->sc_busses[busidx];
 	bus->mux = sc;
 	bus->busidx = busidx;
 	bus->handle = handle;
 	bus->handletype = handletype;
 	bus->bus_data = sc->sc_config->get_bus_info(bus);
 	if (bus->bus_data == NULL) {
 		aprint_error_dev(sc->sc_dev,
 		    "unable to get info for bus %d\n", busidx);
 		return;
+	}
 	iic_tag_init(&bus->controller);
 	bus->controller.ic_cookie = bus;
 	bus->controller.ic_acquire_bus = iicmux_acquire_bus;
 	bus->controller.ic_release_bus = iicmux_release_bus;
 	bus->controller.ic_exec = iicmux_exec;
 	switch (handletype) {
 	case I2C_COOKIE_OF:
 		fdtbus_register_i2c_controller(&bus->controller,
 		    (int)bus->handle);
 		fdtbus_attach_i2cbus(sc->sc_dev, (int)bus->handle,
 		    &bus->controller, iicmux_print);
 		break;
 #if NACPICA > 0
 	case I2C_COOKIE_ACPI: {
 		struct acpi_devnode *ad = acpi_match_node((ACPI_HANDLE)handle);
 		KASSERT(ad != NULL);
 		struct i2cbus_attach_args iba = {
 			.iba_tag = &bus->controller,
-			.iba_child_devices = acpi_enter_i2c_devs(ad)
+			.iba_child_devices = acpi_enter_i2c_devs(NULL, ad)
 		};
 		config_found_ia(sc->sc_dev, "i2cbus", &iba, iicbus_print);
 	}	break;
 #endif
 	default:
 		aprint_error_dev(sc->sc_dev, "unknown handle type\n");
 		break;
+	}
+}
 static void
 iicmux_attach_fdt(struct iicmux_softc * const sc)
+{
 	/*
 	 * We start out assuming that the i2c bus nodes are children of
 	 * our own node.  We'll adjust later if we encounter an "i2c-mux"
 	 * node when counting our children.  If we encounter such a node,
 	 * then it's that node that is the parent of the i2c bus children.
 	 */
 	sc->sc_i2c_mux_phandle = (int)sc->sc_handle;
 	sc->sc_nbusses = iicmux_count_children(sc);
 	if (sc->sc_nbusses == 0) {
 		return;
+	}
 	sc->sc_busses = kmem_zalloc(sizeof(*sc->sc_busses) * sc->sc_nbusses,
 	    KM_SLEEP);
 	int child, idx;
 	for (child = OF_child(sc->sc_i2c_mux_phandle), idx = 0; child;
 	     child = OF_peer(child), idx++) {
 		KASSERT(idx < sc->sc_nbusses);
 		iicmux_attach_bus(sc, child, I2C_COOKIE_OF, idx);
+	}
+}
 #if NACPICA > 0
 static void
 iicmux_attach_acpi(struct iicmux_softc * const sc)
+{
 	ACPI_HANDLE hdl = (ACPI_HANDLE)sc->sc_handle;
 	struct acpi_devnode *devnode, *ad;
 	int idx;
 	devnode = acpi_match_node(hdl);
 	KASSERT(devnode != NULL);
 	/* Count child busses */
 	sc->sc_nbusses = 0;
 	SIMPLEQ_FOREACH(ad, &devnode->ad_child_head, ad_child_list) {
 		if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE ||
 		    !acpi_device_present(ad->ad_handle)) {
 			continue;
+		}
 		sc->sc_nbusses++;
+	}
 	sc->sc_busses = kmem_zalloc(sizeof(*sc->sc_busses) * sc->sc_nbusses,
 	    KM_SLEEP);
 	/* Attach child busses */
 	idx = 0;
 	SIMPLEQ_FOREACH(ad, &devnode->ad_child_head, ad_child_list) {
 		if (ad->ad_devinfo->Type != ACPI_TYPE_DEVICE ||
 		    !acpi_device_present(ad->ad_handle)) {
 			continue;
+		}
 		iicmux_attach_bus(sc, (uintptr_t)ad->ad_handle,
 		    I2C_COOKIE_ACPI, idx);
 		idx++;
+	}
+}
 #endif
 void
 iicmux_attach(struct iicmux_softc * const sc)
+{
 	/*
 	 * We expect sc->sc_handle, sc->sc_config, and sc->sc_i2c_parent
 	 * to be initialized by the front-end.
 	 */
 	KASSERT(sc->sc_handle > 0);
 	KASSERT(sc->sc_config != NULL);
 	KASSERT(sc->sc_i2c_parent != NULL);
 	/*
 	 * Gather up all of the various bits of information needed
 	 * for this particular type of i2c mux.
 	 */
 	sc->sc_mux_data = sc->sc_config->get_mux_info(sc);
 	if (sc->sc_mux_data == NULL) {
 		aprint_error_dev(sc->sc_dev, "unable to get info for mux\n");
 		return;
+	}
 	/*
 	 * Do configuration method (OF, ACPI) specific setup.
 	 */
 	switch (sc->sc_handletype) {
 	case I2C_COOKIE_OF:
 		iicmux_attach_fdt(sc);
 		break;
 #if NACPICA > 0
 	case I2C_COOKIE_ACPI:
 		iicmux_attach_acpi(sc);
 		break;
 #endif
 	default:
 		aprint_error_dev(sc->sc_dev, "could not configure mux: "
 		    "handle type %u not supported\n", sc->sc_handletype);
 		break;
+	}
+}