 @@ -1,14 +1,14 @@
-/* $NetBSD: tpm_acpi.c,v 1.10 2019/10/09 07:30:58 maxv Exp $ */
+/* $NetBSD: tpm_acpi.c,v 1.11 2019/10/09 14:03:57 maxv 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.
 @@ -20,27 +20,27 @@
  * ``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.10 2019/10/09 07:30:58 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tpm_acpi.c,v 1.11 2019/10/09 14:03:57 maxv 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>
 @@ -108,53 +108,46 @@ tpm_acpi_attach(device_t parent, device_
 		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;
 	sc->sc_dev = self;
 	sc->sc_ver = TPM_2_0;
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
 	sc->sc_busy = false;
-	sc->sc_init = tpm_tis12_init;
+	sc->sc_intf = &tpm_intf_tis12;
 	sc->sc_start = tpm_tis12_start;
 	sc->sc_read = tpm_tis12_read;
 	sc->sc_write = tpm_tis12_write;
 	sc->sc_end = tpm_tis12_end;
 	sc->sc_bt = aa->aa_memt;
 	base = mem->ar_base;
 	size = mem->ar_length;
 	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 (!tpm_tis12_probe(sc->sc_bt, sc->sc_bh)) {
+	if ((rv = (*sc->sc_intf->probe)(sc->sc_bt, sc->sc_bh)) != 0) {
-		aprint_error_dev(sc->sc_dev, "TIS1.2 probe failed\n");
+		aprint_error_dev(sc->sc_dev, "probe failed, rv=%d\n", rv);
 		goto out1;
+	}
 	if ((rv = (*sc->sc_intf->init)(sc)) != 0) {
-	if ((*sc->sc_init)(sc) != 0) {
+		aprint_error_dev(sc->sc_dev, "cannot init device, rv=%d\n", rv);
 		aprint_error_dev(sc->sc_dev, "cannot init device %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);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tpm.c,v 1.15 2019/10/09 07:30:58 maxv Exp $	*/
+/*	$NetBSD: tpm.c,v 1.16 2019/10/09 14:03:58 maxv Exp $	*/
 /*
  * Copyright (c) 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by 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.
 @@ -38,27 +38,27 @@
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN
  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: tpm.c,v 1.15 2019/10/09 07:30:58 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tpm.c,v 1.16 2019/10/09 14:03:58 maxv Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
 #include <sys/proc.h>
 #include <sys/device.h>
 #include <sys/conf.h>
 #include <sys/bus.h>
 #include <sys/pmf.h>
 #include <dev/ic/tpmreg.h>
 #include <dev/ic/tpmvar.h>
 @@ -83,62 +83,26 @@ CTASSERT(sizeof(struct tpm_header) == 10
 static inline int
 tpm_tmotohz(int tmo)
+{
 	struct timeval tv;
 	tv.tv_sec = tmo / 1000;
 	tv.tv_usec = 1000 * (tmo % 1000);
 	return tvtohz(&tv);
+}
 static int
 tpm_request_locality(struct tpm_softc *sc, int l)
 	uint32_t r;
 	int to, rv;
 	if (l != 0)
 		return EINVAL;
 	if ((bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_ACCESS) &
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) ==
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY))
 		return 0;
 	bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_ACCESS,
 	    TPM_ACCESS_REQUEST_USE);
 	to = tpm_tmotohz(TPM_ACCESS_TMO);
 	while ((r = bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_ACCESS) &
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) !=
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY) && to--) {
 		rv = tsleep(sc->sc_init, PCATCH, "tpm_locality", 1);
 		if (rv && rv != EWOULDBLOCK) {
 			return rv;
 	if ((r & (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) !=
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) {
 		return EBUSY;
 	return 0;
 static int
 tpm_getburst(struct tpm_softc *sc)
+{
 	int burst, to, rv;
 	to = tpm_tmotohz(TPM_BURST_TMO);
 	while (to--) {
 		/*
 		 * Burst count is in bits 23:8, so read the two higher bytes.
 		 */
 		burst = bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_STS + 1);
 		burst |= bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_STS + 2)
 		    << 8;
 @@ -164,50 +128,50 @@ tpm_status(struct tpm_softc *sc)
 /* -------------------------------------------------------------------------- */
 static bool
 tpm12_suspend(struct tpm_softc *sc)
+{
 	static const uint8_t command[10] = {
 x00, 0xC1,		/* TPM_TAG_RQU_COMMAND */
 x00, 0x00, 0x00, 10,	/* Length in bytes */
 x00, 0x00, 0x00, 0x98	/* TPM_ORD_SaveState */
 	};
 	struct tpm_header response;
-	if ((*sc->sc_write)(sc, &command, sizeof(command)) != 0)
+	if ((*sc->sc_intf->write)(sc, &command, sizeof(command)) != 0)
 		return false;
-	if ((*sc->sc_read)(sc, &response, sizeof(response), NULL, 0) != 0)
+	if ((*sc->sc_intf->read)(sc, &response, sizeof(response), NULL, 0) != 0)
 		return false;
 	if (TPM_BE32(response.code) != 0)
 		return false;
 	return true;
+}
 static bool
 tpm20_suspend(struct tpm_softc *sc)
+{
 	static const uint8_t command[12] = {
 x80, 0x01,		/* TPM_ST_NO_SESSIONS */
 x00, 0x00, 0x00, 12,	/* Length in bytes */
 x00, 0x00, 0x01, 0x45,	/* TPM_CC_Shutdown */
 x00, 0x01		/* TPM_SU_STATE */
 	};
 	struct tpm_header response;
-	if ((*sc->sc_write)(sc, &command, sizeof(command)) != 0)
+	if ((*sc->sc_intf->write)(sc, &command, sizeof(command)) != 0)
 		return false;
-	if ((*sc->sc_read)(sc, &response, sizeof(response), NULL, 0) != 0)
+	if ((*sc->sc_intf->read)(sc, &response, sizeof(response), NULL, 0) != 0)
 		return false;
 	if (TPM_BE32(response.code) != 0)
 		return false;
 	return true;
+}
 bool
 tpm_suspend(device_t dev, const pmf_qual_t *qual)
+{
 	struct tpm_softc *sc = device_private(dev);
 	switch (sc->sc_ver) {
 @@ -276,154 +240,192 @@ restart:
 			bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_STS,
 			    TPM_STS_RESP_RETRY);
 			goto restart;
+		}
 		return EIO;
+	}
 	return 0;
+}
 /* -------------------------------------------------------------------------- */
 /*
- * TPM using TIS 1.2 interface.
+ * TPM using the TIS 1.2 interface.
  */
-int
+static int
 tpm12_request_locality(struct tpm_softc *sc, int l)
+{
 	uint32_t r;
 	int to, rv;
 	if (l != 0)
 		return EINVAL;
 	if ((bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_ACCESS) &
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) ==
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY))
 		return 0;
 	bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_ACCESS,
 	    TPM_ACCESS_REQUEST_USE);
 	to = tpm_tmotohz(TPM_ACCESS_TMO);
 	while ((r = bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_ACCESS) &
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) !=
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY) && to--) {
 		rv = tsleep(sc->sc_intf->init, PCATCH, "tpm_locality", 1);
 		if (rv && rv != EWOULDBLOCK) {
 			return rv;
+		}
+	}
 	if ((r & (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) !=
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) {
 		return EBUSY;
+	}
 	return 0;
+}
 static int
 tpm_tis12_probe(bus_space_tag_t bt, bus_space_handle_t bh)
+{
 	uint32_t cap;
 	uint8_t reg;
 	int tmo;
 	cap = bus_space_read_4(bt, bh, TPM_INTF_CAPABILITY);
 	if (cap == 0xffffffff)
-		return 0;
+		return EINVAL;
 	if ((cap & TPM_CAPS_REQUIRED) != TPM_CAPS_REQUIRED)
-		return 0;
+		return ENOTSUP;
 	/* Request locality 0. */
 	bus_space_write_1(bt, bh, TPM_ACCESS, TPM_ACCESS_REQUEST_USE);
 	/* Wait for it to become active. */
 	tmo = TPM_ACCESS_TMO; /* Milliseconds. */
 	while ((reg = bus_space_read_1(bt, bh, TPM_ACCESS) &
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) !=
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY) && tmo--) {
 		DELAY(1000); /* 1 millisecond. */
+	}
 	if ((reg & (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) !=
 	    (TPM_ACCESS_VALID | TPM_ACCESS_ACTIVE_LOCALITY)) {
-		return 0;
+		return ETIMEDOUT;
+	}
 	if (bus_space_read_4(bt, bh, TPM_ID) == 0xffffffff)
-		return 0;
+		return EINVAL;
-	return 1;
+	return 0;
+}
-int
+static int
 tpm_tis12_init(struct tpm_softc *sc)
+{
 	int rv;
 	sc->sc_caps = bus_space_read_4(sc->sc_bt, sc->sc_bh,
 	    TPM_INTF_CAPABILITY);
 	sc->sc_devid = bus_space_read_4(sc->sc_bt, sc->sc_bh, TPM_ID);
 	sc->sc_rev = bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_REV);
 	aprint_normal_dev(sc->sc_dev, "device 0x%08x rev 0x%x\n",
 	    sc->sc_devid, sc->sc_rev);
-	if (tpm_request_locality(sc, 0))
+	if ((rv = tpm12_request_locality(sc, 0)) != 0)
-		return 1;
+		return rv;
 	/* Abort whatever it thought it was doing. */
 	bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_STS, TPM_STS_CMD_READY);
 	return 0;
+}
-int
+static int
 tpm_tis12_start(struct tpm_softc *sc, int rw)
+{
 	int rv;
 	if (rw == UIO_READ) {
 		rv = tpm_waitfor(sc, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
-		    TPM_READ_TMO, sc->sc_read);
+		    TPM_READ_TMO, sc->sc_intf->read);
 		return rv;
+	}
 	/* Request the 0th locality. */
-	if ((rv = tpm_request_locality(sc, 0)) != 0)
+	if ((rv = tpm12_request_locality(sc, 0)) != 0)
 		return rv;
 	sc->sc_status = tpm_status(sc);
 	if (sc->sc_status & TPM_STS_CMD_READY)
 		return 0;
 	/* Abort previous and restart. */
 	bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_STS, TPM_STS_CMD_READY);
-	rv = tpm_waitfor(sc, TPM_STS_CMD_READY, TPM_READY_TMO, sc->sc_write);
+	rv = tpm_waitfor(sc, TPM_STS_CMD_READY, TPM_READY_TMO, sc->sc_intf->write);
 	if (rv)
 		return rv;
 	return 0;
+}
-int
+static int
 tpm_tis12_read(struct tpm_softc *sc, void *buf, size_t len, size_t *count,
     int flags)
+{
 	uint8_t *p = buf;
 	size_t cnt;
 	int rv, n;
 	cnt = 0;
 	while (len > 0) {
 		rv = tpm_waitfor(sc, TPM_STS_DATA_AVAIL | TPM_STS_VALID,
-		    TPM_READ_TMO, sc->sc_read);
+		    TPM_READ_TMO, sc->sc_intf->read);
 		if (rv)
 			return rv;
 		n = MIN(len, tpm_getburst(sc));
 		while (n > 0) {
 			*p++ = bus_space_read_1(sc->sc_bt, sc->sc_bh, TPM_DATA);
 			cnt++;
 			len--;
 			n--;
+		}
 		if ((flags & TPM_PARAM_SIZE) == 0 && cnt >= 6)
 			break;
+	}
 	if (count)
 		*count = cnt;
 	return 0;
+}
-int
+static int
 tpm_tis12_write(struct tpm_softc *sc, const void *buf, size_t len)
+{
 	const uint8_t *p = buf;
 	size_t cnt;
 	int rv, r;
 	if (len == 0)
 		return 0;
-	if ((rv = tpm_request_locality(sc, 0)) != 0)
+	if ((rv = tpm12_request_locality(sc, 0)) != 0)
 		return rv;
 	cnt = 0;
 	while (cnt < len - 1) {
 		for (r = tpm_getburst(sc); r > 0 && cnt < len - 1; r--) {
 			bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_DATA, *p++);
 			cnt++;
+		}
 		if ((rv = tpm_waitfor(sc, TPM_STS_VALID, TPM_READ_TMO, sc))) {
 			return rv;
+		}
 		sc->sc_status = tpm_status(sc);
 		if (!(sc->sc_status & TPM_STS_DATA_EXPECT)) {
 @@ -434,33 +436,33 @@ tpm_tis12_write(struct tpm_softc *sc, co
 	bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_DATA, *p++);
 	cnt++;
 	if ((rv = tpm_waitfor(sc, TPM_STS_VALID, TPM_READ_TMO, sc))) {
 		return rv;
+	}
 	if ((sc->sc_status & TPM_STS_DATA_EXPECT) != 0) {
 		return EIO;
+	}
 	return 0;
+}
-int
+static int
 tpm_tis12_end(struct tpm_softc *sc, int rw, int err)
+{
 	int rv = 0;
 	if (rw == UIO_READ) {
-		rv = tpm_waitfor(sc, TPM_STS_VALID, TPM_READ_TMO, sc->sc_read);
+		rv = tpm_waitfor(sc, TPM_STS_VALID, TPM_READ_TMO, sc->sc_intf->read);
 		if (rv)
 			return rv;
 		/* Still more data? */
 		sc->sc_status = tpm_status(sc);
 		if (!err && (sc->sc_status & TPM_STS_DATA_AVAIL)) {
 			rv = EIO;
+		}
 		bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_STS,
 		    TPM_STS_CMD_READY);
 		/* Release the 0th locality. */
 @@ -470,26 +472,36 @@ tpm_tis12_end(struct tpm_softc *sc, int
 		/* Hungry for more? */
 		sc->sc_status = tpm_status(sc);
 		if (!err && (sc->sc_status & TPM_STS_DATA_EXPECT)) {
 			rv = EIO;
+		}
 		bus_space_write_1(sc->sc_bt, sc->sc_bh, TPM_STS,
 		    err ? TPM_STS_CMD_READY : TPM_STS_GO);
+	}
 	return rv;
+}
 const struct tpm_intf tpm_intf_tis12 = {
 	.version = TIS_1_2,
 	.probe = tpm_tis12_probe,
 	.init = tpm_tis12_init,
 	.start = tpm_tis12_start,
 	.read = tpm_tis12_read,
 	.write = tpm_tis12_write,
 	.end = tpm_tis12_end
 };
 /* -------------------------------------------------------------------------- */
 static dev_type_open(tpmopen);
 static dev_type_close(tpmclose);
 static dev_type_read(tpmread);
 static dev_type_write(tpmwrite);
 static dev_type_ioctl(tpmioctl);
 const struct cdevsw tpm_cdevsw = {
 	.d_open = tpmopen,
 	.d_close = tpmclose,
 	.d_read = tpmread,
 	.d_write = tpmwrite,
 @@ -545,104 +557,100 @@ tpmclose(dev_t dev, int flag, int mode,
 static int
 tpmread(dev_t dev, struct uio *uio, int flags)
+{
 	struct tpm_softc *sc = device_lookup_private(&tpm_cd, minor(dev));
 	struct tpm_header hdr;
 	uint8_t buf[TPM_BUFSIZ];
 	size_t cnt, len, n;
 	int rv;
 	if (sc == NULL)
 		return ENXIO;
-	if ((rv = (*sc->sc_start)(sc, UIO_READ)))
+	if ((rv = (*sc->sc_intf->start)(sc, UIO_READ)))
-		goto out;
+		return rv;
 	/* Get the header. */
-	if ((rv = (*sc->sc_read)(sc, &hdr, sizeof(hdr), &cnt, 0))) {
+	if ((rv = (*sc->sc_intf->read)(sc, &hdr, sizeof(hdr), &cnt, 0))) {
 		(*sc->sc_end)(sc, UIO_READ, rv);
 		goto out;
+	}
 	len = TPM_BE32(hdr.length);
 	if (len > uio->uio_resid || len < cnt) {
 		rv = EIO;
 		(*sc->sc_end)(sc, UIO_READ, rv);
 		goto out;
+	}
 	/* Copy out the header. */
 	if ((rv = uiomove(&hdr, cnt, uio))) {
 		(*sc->sc_end)(sc, UIO_READ, rv);
 		goto out;
+	}
 	/* Process the rest. */
 	len -= cnt;
 	while (len > 0) {
 		n = MIN(sizeof(buf), len);
-		if ((rv = (*sc->sc_read)(sc, buf, n, NULL, TPM_PARAM_SIZE))) {
+		if ((rv = (*sc->sc_intf->read)(sc, buf, n, NULL, TPM_PARAM_SIZE))) {
 			(*sc->sc_end)(sc, UIO_READ, rv);
 			goto out;
+		}
 		if ((rv = uiomove(buf, n, uio))) {
 			(*sc->sc_end)(sc, UIO_READ, rv);
 			goto out;
+		}
 		len -= n;
+	}
 	rv = (*sc->sc_end)(sc, UIO_READ, rv);
 out:
 	rv = (*sc->sc_intf->end)(sc, UIO_READ, rv);
 	return rv;
+}
 static int
 tpmwrite(dev_t dev, struct uio *uio, int flags)
+{
 	struct tpm_softc *sc = device_lookup_private(&tpm_cd, minor(dev));
 	uint8_t buf[TPM_BUFSIZ];
 	int n, rv;
 	if (sc == NULL)
 		return ENXIO;
 	n = MIN(sizeof(buf), uio->uio_resid);
 	if ((rv = uiomove(buf, n, uio))) {
 		goto out;
+	}
-	if ((rv = (*sc->sc_start)(sc, UIO_WRITE))) {
+	if ((rv = (*sc->sc_intf->start)(sc, UIO_WRITE))) {
 		goto out;
+	}
-	if ((rv = (*sc->sc_write)(sc, buf, n))) {
+	if ((rv = (*sc->sc_intf->write)(sc, buf, n))) {
 		goto out;
+	}
-	rv = (*sc->sc_end)(sc, UIO_WRITE, rv);
+	rv = (*sc->sc_intf->end)(sc, UIO_WRITE, rv);
 out:
 	return rv;
+}
 static int
 tpmioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
+{
 	struct tpm_softc *sc = device_lookup_private(&tpm_cd, minor(dev));
 	struct tpm_ioc_getinfo *info;
 	if (sc == NULL)
 		return ENXIO;
 	switch (cmd) {
 	case TPM_IOC_GETINFO:
 		info = addr;
 		info->api_version = TPM_API_VERSION;
 		info->tpm_version = sc->sc_ver;
 		info->itf_version = sc->sc_intf->version;
 		info->device_id = sc->sc_devid;
 		info->device_rev = sc->sc_rev;
 		info->device_caps = sc->sc_caps;
 		return 0;
 	default:
 		break;
+	}
 	return ENOTTY;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tpm_isa.c,v 1.6 2019/10/09 07:30:58 maxv Exp $	*/
+/*	$NetBSD: tpm_isa.c,v 1.7 2019/10/09 14:03:58 maxv Exp $	*/
 /*
  * Copyright (c) 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by 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.
 @@ -38,27 +38,27 @@
  * purpose with or without fee is hereby granted, provided that the above
  * copyright notice and this permission notice appear in all copies.
+ *
  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN
  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: tpm_isa.c,v 1.6 2019/10/09 07:30:58 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: tpm_isa.c,v 1.7 2019/10/09 14:03:58 maxv 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/isa/isareg.h>
 #include <dev/isa/isavar.h>
 @@ -80,59 +80,56 @@ tpm_isa_match(device_t parent, cfdata_t
 	/* There can be only one. */
 	if (tpm_cd.cd_devs && tpm_cd.cd_devs[0])
 		return 0;
 	if (ia->ia_iomem[0].ir_addr == ISA_UNKNOWN_IOMEM)
 		return 0;
 	/* XXX: integer locator sign extension */
 	if (bus_space_map(bt, (unsigned int)ia->ia_iomem[0].ir_addr,
 	    TPM_SPACE_SIZE, 0, &bh))
 		return 0;
-	if ((rv = tpm_tis12_probe(bt, bh))) {
+	if ((rv = (*tpm_intf_tis12.probe)(bt, bh)) == 0) {
 		ia->ia_nio = 0;
 		ia->ia_io[0].ir_size = 0;
 		ia->ia_iomem[0].ir_size = TPM_SPACE_SIZE;
+	}
 	ia->ia_ndrq = 0;
 	bus_space_unmap(bt, bh, TPM_SPACE_SIZE);
-	return rv;
+	return (rv == 0) ? 1 : 0;
+}
 static void
 tpm_isa_attach(device_t parent, device_t self, void *aux)
+{
 	struct tpm_softc *sc = device_private(self);
 	struct isa_attach_args *ia = aux;
 	bus_addr_t base;
 	bus_size_t size;
 	int rv;
 	base = (unsigned int)ia->ia_iomem[0].ir_addr;
 	size = TPM_SPACE_SIZE;
 	sc->sc_dev = self;
 	sc->sc_ver = TPM_1_2;
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
 	sc->sc_busy = false;
-	sc->sc_init = tpm_tis12_init;
+	sc->sc_intf = &tpm_intf_tis12;
 	sc->sc_start = tpm_tis12_start;
 	sc->sc_read = tpm_tis12_read;
 	sc->sc_write = tpm_tis12_write;
 	sc->sc_end = tpm_tis12_end;
 	sc->sc_bt = ia->ia_memt;
 	base = (unsigned int)ia->ia_iomem[0].ir_addr;
 	size = TPM_SPACE_SIZE;
 	if (bus_space_map(sc->sc_bt, base, size, 0, &sc->sc_bh)) {
 		aprint_error_dev(sc->sc_dev, "cannot map registers\n");
 		return;
+	}
-	if ((*sc->sc_init)(sc) != 0) {
+	if ((rv = (*sc->sc_intf->init)(sc)) != 0) {
 		aprint_error_dev(sc->sc_dev, "cannot init device, rv=%d\n", rv);
 		bus_space_unmap(sc->sc_bt, sc->sc_bh, size);
 		return;
+	}
 	if (!pmf_device_register(self, tpm_suspend, tpm_resume))
 		aprint_error_dev(self, "couldn't establish power handler\n");
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tpmvar.h,v 1.6 2019/10/09 07:30:58 maxv Exp $	*/
+/*	$NetBSD: tpmvar.h,v 1.7 2019/10/09 14:03:58 maxv Exp $	*/
 /*
  * Copyright (c) 2019 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by 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.
 @@ -26,57 +26,65 @@
  * 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.
  */
 #define TPM_API_VERSION		1
 enum tpm_version {
 	TPM_1_2,
 	TPM_2_0
 };
 enum itf_version {
 	TIS_1_2,
 	CRB
 };
 struct tpm_ioc_getinfo {
 	uint32_t api_version;
 	uint32_t tpm_version;
 	uint32_t itf_version;
 	uint32_t device_id;
 	uint32_t device_rev;
 	uint32_t device_caps;
 };
 #define TPM_IOC_GETINFO		_IOR ('N',  0, struct tpm_ioc_getinfo)
 #ifdef _KERNEL
 struct tpm_softc;
 struct tpm_intf {
 	enum itf_version version;
 	int (*probe)(bus_space_tag_t, bus_space_handle_t);
 	int (*init)(struct tpm_softc *);
 	int (*start)(struct tpm_softc *, int);
 	int (*read)(struct tpm_softc *, void *, size_t, size_t *, int);
 	int (*write)(struct tpm_softc *, const void *, size_t);
 	int (*end)(struct tpm_softc *, int, int);
 };
 extern const struct tpm_intf tpm_intf_tis12;
 struct tpm_softc {
 	device_t sc_dev;
 	enum tpm_version sc_ver;
 	kmutex_t sc_lock;
 	bool sc_busy;
-	int (*sc_init)(struct tpm_softc *);
+	const struct tpm_intf *sc_intf;
 	int (*sc_start)(struct tpm_softc *, int);
 	int (*sc_read)(struct tpm_softc *, void *, size_t, size_t *, int);
 	int (*sc_write)(struct tpm_softc *, const void *, size_t);
 	int (*sc_end)(struct tpm_softc *, int, int);
 	bus_space_tag_t sc_bt;
 	bus_space_handle_t sc_bh;
 	uint32_t sc_devid;
 	uint32_t sc_rev;
 	uint32_t sc_status;
 	uint32_t sc_caps;
 };
 bool tpm_suspend(device_t, const pmf_qual_t *);
 bool tpm_resume(device_t, const pmf_qual_t *);
 int tpm_tis12_probe(bus_space_tag_t, bus_space_handle_t);
 int tpm_tis12_init(struct tpm_softc *);
 int tpm_tis12_start(struct tpm_softc *, int);
 int tpm_tis12_read(struct tpm_softc *, void *, size_t, size_t *, int);
 int tpm_tis12_write(struct tpm_softc *, const void *, size_t);
 int tpm_tis12_end(struct tpm_softc *, int, int);
 #endif