 @@ -1,237 +1,237 @@
-/*	$NetBSD: acpi_button.c,v 1.42 2015/04/23 23:23:00 pgoyette Exp $	*/
+/*	$NetBSD: acpi_button.c,v 1.43 2021/01/29 15:24:00 thorpej Exp $	*/
 /*
  * 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.
  */
 /*
  * ACPI Button driver.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: acpi_button.c,v 1.42 2015/04/23 23:23:00 pgoyette Exp $");
+__KERNEL_RCSID(0, "$NetBSD: acpi_button.c,v 1.43 2021/01/29 15:24:00 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/device.h>
 #include <sys/module.h>
 #include <sys/systm.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_wakedev.h>
 #define _COMPONENT		 ACPI_BUTTON_COMPONENT
 ACPI_MODULE_NAME		 ("acpi_button")
 #define ACPI_NOTIFY_BUTTON	 0x80
 struct acpibut_softc {
 	struct acpi_devnode	*sc_node;
 	struct sysmon_pswitch	 sc_smpsw;
 };
-static const char * const power_button_hid[] = {
+struct button_type {
-	"PNP0C0C",
+	const char *desc;
-	NULL
+	int type;
 };
 static const struct button_type power_button_type = {
 	.desc = "Power",
 	.type = PSWITCH_TYPE_POWER
 };
-static const char * const sleep_button_hid[] = {
+static const struct button_type sleep_button_type = {
-	"PNP0C0E",
+	.desc = "Sleep",
-	NULL
+	.type = PSWITCH_TYPE_SLEEP
 };
 static const struct device_compatible_entry compat_data[] = {
 	{ .compat = "PNP0C0C",	.data = &power_button_type },
 	{ .compat = "PNP0C0E",	.data = &sleep_button_type },
 	DEVICE_COMPAT_EOL
 };
 static int	acpibut_match(device_t, cfdata_t, void *);
 static void	acpibut_attach(device_t, device_t, void *);
 static int	acpibut_detach(device_t, int);
 static void	acpibut_pressed_event(void *);
 static void	acpibut_notify_handler(ACPI_HANDLE, uint32_t, void *);
 CFATTACH_DECL_NEW(acpibut, sizeof(struct acpibut_softc),
     acpibut_match, acpibut_attach, acpibut_detach, NULL);
 /*
  * acpibut_match:
+ *
  *	Autoconfiguration `match' routine.
  */
 static int
 acpibut_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct acpi_attach_args *aa = aux;
-	if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
+	return acpi_compatible_match(aa, compat_data);
 		return 0;
 	if (acpi_match_hid(aa->aa_node->ad_devinfo, power_button_hid))
 		return 1;
 	if (acpi_match_hid(aa->aa_node->ad_devinfo, sleep_button_hid))
 		return 1;
 	return 0;
+}
 /*
  * acpibut_attach:
+ *
  *	Autoconfiguration `attach' routine.
  */
 static void
 acpibut_attach(device_t parent, device_t self, void *aux)
+{
 	struct acpibut_softc *sc = device_private(self);
 	struct acpi_attach_args *aa = aux;
 	const struct device_compatible_entry *dce;
 	const struct button_type *type;
 	struct acpi_wakedev *aw;
 	const char *desc;
 	sc->sc_smpsw.smpsw_name = device_xname(self);
-	if (acpi_match_hid(aa->aa_node->ad_devinfo, power_button_hid)) {
+	dce = acpi_compatible_lookup(aa, compat_data);
-		sc->sc_smpsw.smpsw_type = PSWITCH_TYPE_POWER;
+	KASSERT(dce != NULL);
-		desc = "Power";
+	type = dce->data;
 	} else if (acpi_match_hid(aa->aa_node->ad_devinfo, sleep_button_hid)) {
-		sc->sc_smpsw.smpsw_type = PSWITCH_TYPE_SLEEP;
+	sc->sc_smpsw.smpsw_type = type->type;
 		desc = "Sleep";
 	} else
 		panic("%s: impossible", __func__);
-	aprint_naive(": ACPI %s Button\n", desc);
+	aprint_naive(": ACPI %s Button\n", type->desc);
-	aprint_normal(": ACPI %s Button\n", desc);
+	aprint_normal(": ACPI %s Button\n", type->desc);
 	sc->sc_node = aa->aa_node;
 	aw = sc->sc_node->ad_wakedev;
 	/*
 	 * This GPE should always be enabled.
 	 */
 	if (aw != NULL)
 		(void)AcpiEnableGpe(aw->aw_handle, aw->aw_number);
 	(void)pmf_device_register(self, NULL, NULL);
 	(void)sysmon_pswitch_register(&sc->sc_smpsw);
 	(void)acpi_register_notify(sc->sc_node, acpibut_notify_handler);
+}
 /*
  * acpibut_detach:
+ *
  *	Autoconfiguration `detach' routine.
  */
 static int
 acpibut_detach(device_t self, int flags)
+{
 	struct acpibut_softc *sc = device_private(self);
 	pmf_device_deregister(self);
 	acpi_deregister_notify(sc->sc_node);
 	sysmon_pswitch_unregister(&sc->sc_smpsw);
 	return 0;
+}
 /*
  * acpibut_pressed_event:
+ *
  *	Deal with a button being pressed.
  */
 static void
 acpibut_pressed_event(void *arg)
+{
 	device_t dv = arg;
 	struct acpibut_softc *sc = device_private(dv);
 	aprint_debug_dev(dv, "button pressed\n");
 	sysmon_pswitch_event(&sc->sc_smpsw, PSWITCH_EVENT_PRESSED);
+}
 /*
  * acpibut_notify_handler:
+ *
  *	Callback from ACPI interrupt handler to notify us of an event.
  */
 static void
 acpibut_notify_handler(ACPI_HANDLE handle, uint32_t notify, void *context)
+{
 	static const int handler = OSL_NOTIFY_HANDLER;
 	device_t dv = context;
 	switch (notify) {
 	case ACPI_NOTIFY_BUTTON:
 		(void)AcpiOsExecute(handler, acpibut_pressed_event, dv);
 		break;
 	case ACPI_NOTIFY_DEVICE_WAKE:
 		break;
 	default:
 		aprint_debug_dev(dv, "unknown notify 0x%02X\n", notify);
+	}
+}
 MODULE(MODULE_CLASS_DRIVER, acpibut, "sysmon_power");
 #ifdef _MODULE
 #include "ioconf.c"
 #endif
 static int
 acpibut_modcmd(modcmd_t cmd, void *aux)
+{
 	int rv = 0;
 	switch (cmd) {
 	case MODULE_CMD_INIT:
 #ifdef _MODULE
 		rv = config_init_component(cfdriver_ioconf_acpibut,
 		    cfattach_ioconf_acpibut, cfdata_ioconf_acpibut);
 #endif
 		break;
 	case MODULE_CMD_FINI:
 #ifdef _MODULE
 		rv = config_fini_component(cfdriver_ioconf_acpibut,
 		    cfattach_ioconf_acpibut, cfdata_ioconf_acpibut);
 #endif
 		break;
 	default:
 		rv = ENOTTY;
+	}
 	return rv;
+}

 @@ -1,194 +1,207 @@
-/* $NetBSD: com_acpi.c,v 1.40 2019/03/01 09:21:06 mlelstv Exp $ */
+/* $NetBSD: com_acpi.c,v 1.41 2021/01/29 15:24:00 thorpej Exp $ */
 /*
  * Copyright (c) 2002 Jared D. 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. 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: com_acpi.c,v 1.40 2019/03/01 09:21:06 mlelstv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: com_acpi.c,v 1.41 2021/01/29 15:24:00 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/device.h>
 #include <sys/systm.h>
 #include <sys/termios.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_intr.h>
 #include <dev/ic/comvar.h>
 static int	com_acpi_match(device_t, cfdata_t , void *);
 static void	com_acpi_attach(device_t, device_t, void *);
 struct com_acpi_softc {
 	struct com_softc sc_com;
 	void *sc_ih;
 };
 CFATTACH_DECL_NEW(com_acpi, sizeof(struct com_acpi_softc), com_acpi_match,
     com_acpi_attach, NULL, NULL);
 /*
  * Supported device IDs
  */
-static const char * const com_acpi_ids[] = {
+static const struct device_compatible_entry compat_data[] = {
-	"PNP0500",	/* Standard PC COM port */
+	/* Standard PC COM port */
-	"PNP0501",	/* 16550A-compatible COM port */
+	{ .compat = "PNP0500",		.value = COM_TYPE_NORMAL },
 	"PNP0510",	/* Generic IRDA-compatible device */
 	"PNP0511",	/* Generic IRDA-compatible device */
 	"IBM0071",	/* IBM ThinkPad IRDA device */
 	"SMCF010",	/* SMC SuperIO IRDA device */
 	"NSC6001",	/* NSC IRDA device */
 	"FUJ02E6",	/* Fujitsu Serial Pen Tablet */
 	"HISI0031",	/* Hisilicon UART */
 	"8250dw",	/* Designware APB UART */
 	NULL
 };
-/*
+	/* 16550A-compatible COM port */
- * Subset of supported device IDs of type COM_TYPE_DW_APB
+	{ .compat = "PNP0501",		.value = COM_TYPE_NORMAL },
  */
-static const char * const com_acpi_dw_ids[] = {
+	/* Generic IRDA-compatible device */
-	"HISI0031",	/* Hisilicon UART */
+	{ .compat = "PNP0510",		.value = COM_TYPE_NORMAL },
 	"8250dw",	/* Designware APB UART */
-	NULL
+	/* Generic IRDA-compatible device */
 	{ .compat = "PNP0511",		.value = COM_TYPE_NORMAL },
 	/* IBM ThinkPad IRDA device */
 	{ .compat = "IBM0071",		.value = COM_TYPE_NORMAL },
 	/* SMC SuperIO IRDA device */
 	{ .compat = "SMCF010",		.value = COM_TYPE_NORMAL },
 	/* NSC IRDA device */
 	{ .compat = "NSC6001",		.value = COM_TYPE_NORMAL },
 	/* Fujitsu Serial Pen Tablet */
 	{ .compat = "FUJ02E6",		.value = COM_TYPE_NORMAL },
 	/* Hisilicon UART */
 	{ .compat = "HISI0031",		.value = COM_TYPE_DW_APB },
 	/* Designware APB UART */
 	{ .compat = "8250dw",		.value = COM_TYPE_DW_APB },
 	DEVICE_COMPAT_EOL
 };
 /*
  * com_acpi_match: autoconf(9) match routine
  */
 static int
 com_acpi_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct acpi_attach_args *aa = aux;
-	if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
+	return acpi_compatible_match(aa, compat_data);
 		return 0;
 	return acpi_match_hid(aa->aa_node->ad_devinfo, com_acpi_ids);
+}
 /*
  * com_acpi_attach: autoconf(9) attach routine
  */
 static void
 com_acpi_attach(device_t parent, device_t self, void *aux)
+{
 	struct com_acpi_softc *asc = device_private(self);
 	struct com_softc *sc = &asc->sc_com;
 	struct acpi_attach_args *aa = aux;
 	const struct device_compatible_entry *dce;
 	struct acpi_resources res;
 	struct acpi_io *io;
 	struct acpi_mem *mem;
 	struct acpi_irq *irq;
 	bus_space_tag_t iot;
 	bus_space_handle_t ioh;
 	bus_addr_t base;
 	bus_size_t size;
 	ACPI_STATUS rv;
 	ACPI_INTEGER clock_freq;
 	sc->sc_dev = self;
 	/* parse resources */
 	rv = acpi_resource_parse(sc->sc_dev, aa->aa_node->ad_handle, "_CRS",
 	    &res, &acpi_resource_parse_ops_default);
 	if (ACPI_FAILURE(rv))
 		return;
 	/* find our i/o registers */
 	io = acpi_res_io(&res, 0);
 	if (io != NULL) {
 		iot = aa->aa_iot;
 		base = io->ar_base;
 		size = io->ar_length;
 	} else {
 		mem = acpi_res_mem(&res, 0);
 		if (mem != NULL) {
 			iot = aa->aa_memt;
 			base = mem->ar_base;
 			size = mem->ar_length;
 		} else {
 			aprint_error_dev(self, "unable to find i/o register "
 			    "and memory resource\n");
 			goto out;
+		}
+	}
 	/* find our IRQ */
 	irq = acpi_res_irq(&res, 0);
 	if (irq == NULL) {
 		aprint_error_dev(self, "unable to find irq resource\n");
 		goto out;
+	}
 	if (!com_is_console(iot, base, &ioh))
 		if (bus_space_map(iot, base, size, 0, &ioh)) {
 			aprint_error_dev(self, "can't map i/o space\n");
 			goto out;
+		}
 	com_init_regs(&sc->sc_regs, iot, ioh, base);
 	aprint_normal("%s", device_xname(self));
-	if (acpi_match_hid(aa->aa_node->ad_devinfo, com_acpi_dw_ids) != 0) {
+	dce = acpi_compatible_lookup(aa, compat_data);
-		sc->sc_type = COM_TYPE_DW_APB;
+	KASSERT(dce != NULL);
 	sc->sc_type = dce->value;
 	if (sc->sc_type == COM_TYPE_DW_APB) {
 		SET(sc->sc_hwflags, COM_HW_POLL);	/* XXX */
 	} else {
 		if (com_probe_subr(&sc->sc_regs) == 0) {
 			aprint_error(": com probe failed\n");
 			goto out;
+		}
+	}
 	rv = acpi_dsd_integer(aa->aa_node->ad_handle, "clock-frequency",
 	    &clock_freq);
 	if (ACPI_SUCCESS(rv))
 		sc->sc_frequency = clock_freq;
 	else
 		sc->sc_frequency = 115200 * 16;
 	com_attach_subr(sc);
 	if (!ISSET(sc->sc_hwflags, COM_HW_POLL))
 		asc->sc_ih = acpi_intr_establish(self,
 		    (uint64_t)(uintptr_t)aa->aa_node->ad_handle,
 		    IPL_SERIAL, true, comintr, sc, device_xname(self));
 	if (!pmf_device_register(self, NULL, com_resume))
 		aprint_error_dev(self, "couldn't establish a power handler\n");
 	goto cleanup;
 	/*
 	 * In case of irq resource or i/o space mapping error, just set
 	 * a NULL power handler.  This may allow us to sleep later on.
 	 */
  out:
 	if (!pmf_device_register(self, NULL, NULL))
 		aprint_error_dev(self, "couldn't establish a power handler\n");
  cleanup:
 	acpi_resource_cleanup(&res);
+}

 @@ -1,273 +1,260 @@
-/*	$NetBSD: pckbc_acpi.c,v 1.38 2020/12/06 12:23:13 jmcneill Exp $	*/
+/*	$NetBSD: pckbc_acpi.c,v 1.39 2021/01/29 15:24:00 thorpej Exp $	*/
 /*-
  * Copyright (c) 2000 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.
  */
 /*
  * ACPI attachment for the PC Keyboard Controller driver.
+ *
  * This is a little wonky.  The keyboard controller actually
  * has 2 ACPI nodes: one for the controller and the keyboard
  * interrupt, and one for the aux port (mouse) interrupt.
+ *
  * For this reason, we actually attach *two* instances of this
  * driver.  After both of them have been found, then we attach
  * sub-devices.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: pckbc_acpi.c,v 1.38 2020/12/06 12:23:13 jmcneill Exp $");
+__KERNEL_RCSID(0, "$NetBSD: pckbc_acpi.c,v 1.39 2021/01/29 15:24:00 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/callout.h>
 #include <sys/device.h>
 #include <sys/malloc.h>
 #include <sys/systm.h>
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_intr.h>
 #include <dev/isa/isareg.h>
 #include <dev/ic/i8042reg.h>
 #include <dev/ic/pckbcvar.h>
 #include "ioconf.h"
 static int	pckbc_acpi_match(device_t, cfdata_t, void *);
 static void	pckbc_acpi_attach(device_t, device_t, void *);
 struct pckbc_acpi_softc {
 	struct pckbc_softc sc_pckbc;
 	ACPI_HANDLE sc_handle;
 	pckbc_slot_t sc_slot;
 };
 /* Save first port: */
 static struct pckbc_acpi_softc *first;
 CFATTACH_DECL_NEW(pckbc_acpi, sizeof(struct pckbc_acpi_softc),
     pckbc_acpi_match, pckbc_acpi_attach, NULL, NULL);
 static void	pckbc_acpi_intr_establish(struct pckbc_softc *, pckbc_slot_t);
 static void	pckbc_acpi_finish_attach(device_t);
 /*
  * Supported Device IDs
  */
-static const char * const pckbc_acpi_ids_kbd[] = {
+static const struct device_compatible_entry compat_data[] = {
-	"PNP03??",	/* Standard PC KBD port */
+	/* Standard PC KBD port */
-	NULL
+	{ .compat = "PNP03??",		.value = PCKBC_KBD_SLOT },
 };
 	/* (Nobody else here but us mouses...) */
 	{ .compat = "PNP0F03",		.value = PCKBC_AUX_SLOT },
 	{ .compat = "PNP0F0E",		.value = PCKBC_AUX_SLOT },
 	{ .compat = "PNP0F12",		.value = PCKBC_AUX_SLOT },
 	{ .compat = "PNP0F13",		.value = PCKBC_AUX_SLOT },
 	{ .compat = "PNP0F19",		.value = PCKBC_AUX_SLOT },
 	{ .compat = "PNP0F1B",		.value = PCKBC_AUX_SLOT },
 	{ .compat = "PNP0F1C",		.value = PCKBC_AUX_SLOT },
 	{ .compat = "SYN0302",		.value = PCKBC_AUX_SLOT },
-static const char * const pckbc_acpi_ids_ms[] = {
+	DEVICE_COMPAT_EOL
 	"PNP0F03",
 	"PNP0F0E",
 	"PNP0F12",
 	"PNP0F13",
 	"PNP0F19",
 	"PNP0F1B",
 	"PNP0F1C",
 	"SYN0302",
 	NULL
 };
 /*
  * pckbc_acpi_match: autoconf(9) match routine
  */
 static int
 pckbc_acpi_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct acpi_attach_args *aa = aux;
 	int rv;
 	if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
 		return 0;
-	rv = acpi_match_hid(aa->aa_node->ad_devinfo, pckbc_acpi_ids_kbd);
+	return acpi_compatible_match(aa, compat_data);
 	if (rv)
 		return rv;
 	rv = acpi_match_hid(aa->aa_node->ad_devinfo, pckbc_acpi_ids_ms);
 	if (rv)
 		return rv;
 	return 0;
+}
 static void
 pckbc_acpi_attach(device_t parent, device_t self, void *aux)
+{
 	struct pckbc_acpi_softc *psc = device_private(self);
 	struct pckbc_softc *sc = &psc->sc_pckbc;
 	struct pckbc_internal *t;
 	struct acpi_attach_args *aa = aux;
 	const struct device_compatible_entry *dce;
 	bus_space_handle_t ioh_d, ioh_c;
 	struct acpi_resources res;
 	struct acpi_io *io0, *io1, *ioswap;
 	struct acpi_irq *irq;
 	ACPI_STATUS rv;
 	sc->sc_dv = self;
-	if (acpi_match_hid(aa->aa_node->ad_devinfo, pckbc_acpi_ids_kbd)) {
+	dce = acpi_compatible_lookup(aa, compat_data);
-		psc->sc_slot = PCKBC_KBD_SLOT;
+	KASSERT(dce != NULL);
 	} else if (acpi_match_hid(aa->aa_node->ad_devinfo, pckbc_acpi_ids_ms)) {
-		psc->sc_slot = PCKBC_AUX_SLOT;
+	psc->sc_slot = dce->value;
 	} else {
 		aprint_error(": unknown port!\n");
 		panic("pckbc_acpi_attach: impossible");
 	aprint_normal(" (%s port)", pckbc_slot_names[psc->sc_slot]);
 	/* parse resources */
 	rv = acpi_resource_parse(sc->sc_dv, aa->aa_node->ad_handle, "_CRS",
 	    &res, &acpi_resource_parse_ops_default);
 	if (ACPI_FAILURE(rv))
 		return;
 	/* find our IRQ */
 	irq = acpi_res_irq(&res, 0);
 	if (irq == NULL) {
 		aprint_error_dev(self, "unable to find irq resource\n");
 		goto out;
+	}
 	psc->sc_handle = aa->aa_node->ad_handle;
 	if (psc->sc_slot == PCKBC_KBD_SLOT)
 		first = psc;
 	if ((!first || !first->sc_pckbc.id) &&
 	    (psc->sc_slot == PCKBC_KBD_SLOT)) {
 		io0 = acpi_res_io(&res, 0);
 		io1 = acpi_res_io(&res, 1);
 		if (io0 == NULL || io1 == NULL) {
 			aprint_error_dev(self,
 			    "unable to find i/o resources\n");
 			goto out;
+		}
 		/*
 		 * JDM: Some firmware doesn't report resources in the order we
 		 * expect; sort IO resources here (lowest first)
 		 */
 		if (io0->ar_base > io1->ar_base) {
 			ioswap = io0;
 			io0 = io1;
 			io1 = ioswap;
+		}
 		if (pckbc_is_console(aa->aa_iot, io0->ar_base)) {
 			t = &pckbc_consdata;
 			ioh_d = t->t_ioh_d;
 			ioh_c = t->t_ioh_c;
 			pckbc_console_attached = 1;
 			/* t->t_cmdbyte was initialized by cnattach */
 		} else {
 			if (bus_space_map(aa->aa_iot, io0->ar_base,
 					  io0->ar_length, 0, &ioh_d) ||
 			    bus_space_map(aa->aa_iot, io1->ar_base,
 					  io1->ar_length, 0, &ioh_c)) {
 				aprint_error_dev(self,
 				    "unable to map registers\n");
 				goto out;
+			}
 			t = malloc(sizeof(struct pckbc_internal),
 			    M_DEVBUF, M_WAITOK|M_ZERO);
 			t->t_iot = aa->aa_iot;
 			t->t_ioh_d = ioh_d;
 			t->t_ioh_c = ioh_c;
 			t->t_addr = io0->ar_base;
 			t->t_cmdbyte = KC8_CPU;	/* Enable ports */
 			callout_init(&t->t_cleanup, 0);
+		}
 		t->t_sc = &first->sc_pckbc;
 		first->sc_pckbc.id = t;
 		if (!pmf_device_register(self, NULL, pckbc_resume))
 			aprint_error_dev(self,
 			    "couldn't establish power handler\n");
 		first->sc_pckbc.intr_establish = pckbc_acpi_intr_establish;
 		config_defer(first->sc_pckbc.sc_dv, pckbc_acpi_finish_attach);
+	}
 out:
 	if (!pmf_device_register(self, NULL, NULL))
 		aprint_error_dev(self, "couldn't establish power handler\n");
 	acpi_resource_cleanup(&res);
+}
 static void
 pckbc_acpi_intr_establish(struct pckbc_softc *sc, pckbc_slot_t slot)
+{
 	struct pckbc_acpi_softc *psc = NULL; /* XXX: gcc */
 	void *rv = NULL;
 	ACPI_HANDLE handle;
 	char intr_name[64];
 	int i;
 	/*
 	 * Note we're always called with sc == first.
 	 */
 	for (i = 0; i < pckbc_cd.cd_ndevs; i++) {
 		psc = device_lookup_private(&pckbc_cd, i);
 		if (psc && psc->sc_slot == slot) {
 			handle = psc->sc_handle;
 			break;
+		}
+	}
 	if (i < pckbc_cd.cd_ndevs) {
 		snprintf(intr_name, sizeof(intr_name), "%s %s",
 		    device_xname(psc->sc_pckbc.sc_dv), pckbc_slot_names[slot]);
 		rv = acpi_intr_establish(sc->sc_dv, (uint64_t)(uintptr_t)handle,
 		    IPL_TTY, false, pckbcintr, sc, intr_name);
+	}
 	if (rv == NULL) {
 		aprint_error_dev(sc->sc_dv,
 		    "unable to establish interrupt for %s slot\n",
 		    pckbc_slot_names[slot]);
 	} else {
 		aprint_normal_dev(sc->sc_dv, "using %s for %s slot\n",
 		    acpi_intr_string(rv, intr_name, sizeof(intr_name)),
 		    pckbc_slot_names[slot]);
+	}
+}
 static void
 pckbc_acpi_finish_attach(device_t dv)
+{
 	pckbc_attach(device_private(dv));
+}

 @@ -1,170 +1,163 @@
-/* $NetBSD: tpm_acpi.c,v 1.12 2021/01/16 01:23:04 thorpej Exp $ */
+/* $NetBSD: tpm_acpi.c,v 1.13 2021/01/29 15:24:00 thorpej Exp $ */
 /*
  * Copyright (c) 2012, 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Christos Zoulas and Maxime Villard.
+ *
  * 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: tpm_acpi.c,v 1.12 2021/01/16 01:23:04 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tpm_acpi.c,v 1.13 2021/01/29 15:24:00 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/bus.h>
 #include <sys/pmf.h>
 #include <dev/ic/tpmreg.h>
 #include <dev/ic/tpmvar.h>
 #include <dev/acpi/acpireg.h>
 #include <dev/acpi/acpivar.h>
 #include "ioconf.h"
 #define _COMPONENT	ACPI_RESOURCE_COMPONENT
 ACPI_MODULE_NAME	("tpm_acpi")
 static int	tpm_acpi_match(device_t, cfdata_t, void *);
 static void	tpm_acpi_attach(device_t, device_t, void *);
 CFATTACH_DECL_NEW(tpm_acpi, sizeof(struct tpm_softc), tpm_acpi_match,
     tpm_acpi_attach, NULL, NULL);
-/*
+static const struct device_compatible_entry compat_data[] = {
- * Supported TPM 1.2 devices.
+	{ .compat = "PNP0C31",		.value = TPM_1_2 },
- */
+	{ .compat = "MSFT0101",		.value = TPM_2_0 },
-static const char * const tpm_1_2_acpi_ids[] = {
+	DEVICE_COMPAT_EOL
 	"PNP0C31",
 	NULL
 };
 /*
  * Supported TPM 2.0 devices.
  */
 static const char * const tpm2_acpi_ids[] = {
 	"MSFT0101",
 	NULL
 };
 static int
 tpm_acpi_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct acpi_attach_args *aa = aux;
 	const struct device_compatible_entry *dce;
 	ACPI_TABLE_TPM2 *tpm2;
 	ACPI_STATUS rv;
 	int ret;
 	if (aa->aa_node->ad_type != ACPI_TYPE_DEVICE)
 		return 0;
 	/* We support only one TPM. */
 	if (tpm_cd.cd_devs && tpm_cd.cd_devs[0])
 		return 0;
-	if (acpi_match_hid(aa->aa_node->ad_devinfo, tpm_1_2_acpi_ids)) {
+	ret = acpi_compatible_match(aa, compat_data);
 	if (ret == 0)
 		return 0;
 	dce = acpi_compatible_lookup(aa, compat_data);
 	KASSERT(dce != NULL);
 	if (dce->value == TPM_1_2) {
 		/* XXX assume TPM 1.2 devices are memory-mapped. */
-		return 1;
+		return ret;
+	}
 	if (!acpi_match_hid(aa->aa_node->ad_devinfo, tpm2_acpi_ids))
 		return 0;
 	/* Make sure it uses TIS, and not CRB. */
 	rv = AcpiGetTable(ACPI_SIG_TPM2, 1, (ACPI_TABLE_HEADER **)&tpm2);
 	if (ACPI_FAILURE(rv))
 		return 0;
 	if (tpm2->StartMethod != ACPI_TPM2_MEMORY_MAPPED)
 		return 0;
-	return 1;
+	return ret;
+}
 static void
 tpm_acpi_attach(device_t parent, device_t self, void *aux)
+{
 	struct tpm_softc *sc = device_private(self);
 	struct acpi_attach_args *aa = aux;
 	const struct device_compatible_entry *dce;
 	struct acpi_resources res;
 	struct acpi_mem *mem;
 	bus_addr_t base;
 	bus_addr_t size;
 	int rv;
 	rv = acpi_resource_parse(self, aa->aa_node->ad_handle, "_CRS", &res,
 	    &acpi_resource_parse_ops_default);
 	if (ACPI_FAILURE(rv)) {
 		aprint_error_dev(self, "cannot parse resources %d\n", rv);
 		return;
+	}
 	mem = acpi_res_mem(&res, 0);
 	if (mem == NULL) {
 		aprint_error_dev(self, "cannot find mem\n");
 		goto out;
+	}
 	if (mem->ar_length != TPM_SPACE_SIZE) {
 		aprint_error_dev(self, "wrong size mem %"PRIu64" != %u\n",
 		    (uint64_t)mem->ar_length, TPM_SPACE_SIZE);
 		goto out;
+	}
 	base = mem->ar_base;
 	size = mem->ar_length;
 	dce = acpi_compatible_lookup(aa, compat_data);
 	KASSERT(dce != NULL);
 	sc->sc_dev = self;
-	if (acpi_match_hid(aa->aa_node->ad_devinfo, tpm_1_2_acpi_ids)) {
+	sc->sc_ver = dce->value;
 		sc->sc_ver = TPM_1_2;
 	} else {
 		sc->sc_ver = TPM_2_0;
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
 	sc->sc_busy = false;
 	sc->sc_intf = &tpm_intf_tis12;
 	sc->sc_bt = aa->aa_memt;
 	if (bus_space_map(sc->sc_bt, base, size, 0, &sc->sc_bh)) {
 		aprint_error_dev(sc->sc_dev, "cannot map registers\n");
 		goto out;
+	}
 	if ((rv = (*sc->sc_intf->probe)(sc->sc_bt, sc->sc_bh)) != 0) {
 		aprint_error_dev(sc->sc_dev, "probe failed, rv=%d\n", rv);
 		goto out1;
+	}
 	if ((rv = (*sc->sc_intf->init)(sc)) != 0) {
 		aprint_error_dev(sc->sc_dev, "cannot init device, rv=%d\n", rv);
 		goto out1;
+	}
 	if (!pmf_device_register(self, tpm_suspend, tpm_resume))
 		aprint_error_dev(self, "couldn't establish power handler\n");
 	acpi_resource_cleanup(&res);
 	return;
 out1:
 	bus_space_unmap(sc->sc_bt, sc->sc_bh, size);
 out:
 	acpi_resource_cleanup(&res);
+}