 @@ -1,14 +1,14 @@
-/* $NetBSD: ihidev.c,v 1.20 2021/08/07 16:19:11 thorpej Exp $ */
+/* $NetBSD: ihidev.c,v 1.21 2022/01/14 22:25:49 riastradh Exp $ */
 /* $OpenBSD ihidev.c,v 1.13 2017/04/08 02:57:23 deraadt 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
 @@ -44,33 +44,33 @@
  * WHATSOEVER RESULTING FROM LOSS OF 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.
  */
 /*
  * HID-over-i2c driver
+ *
  * https://msdn.microsoft.com/en-us/library/windows/hardware/dn642101%28v=vs.85%29.aspx
+ *
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ihidev.c,v 1.20 2021/08/07 16:19:11 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ihidev.c,v 1.21 2022/01/14 22:25:49 riastradh Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/device.h>
 #include <sys/kmem.h>
 #include <sys/workqueue.h>
 #include <dev/i2c/i2cvar.h>
 #include <dev/i2c/ihidev.h>
 #include <dev/hid/hid.h>
 #if defined(__i386__) || defined(__amd64__)
 #  include "acpica.h"
 #endif
 #if NACPICA > 0
 #include <dev/acpi/acpivar.h>
 #include <dev/acpi/acpi_intr.h>
 #endif
 @@ -100,34 +100,34 @@ enum {
 	/* pseudo commands */
 	I2C_HID_REPORT_DESCR	= 0x100,
 };
 static int I2C_HID_POWER_ON	= 0x0;
 static int I2C_HID_POWER_OFF	= 0x1;
 static int	ihidev_match(device_t, cfdata_t, void *);
 static void	ihidev_attach(device_t, device_t, void *);
 static int	ihidev_detach(device_t, int);
 CFATTACH_DECL_NEW(ihidev, sizeof(struct ihidev_softc),
     ihidev_match, ihidev_attach, ihidev_detach, NULL);
-static bool	ihiddev_intr_init(struct ihidev_softc *);
+static bool	ihidev_intr_init(struct ihidev_softc *);
-static void	ihiddev_intr_fini(struct ihidev_softc *);
+static void	ihidev_intr_fini(struct ihidev_softc *);
 static bool	ihidev_suspend(device_t, const pmf_qual_t *);
 static bool	ihidev_resume(device_t, const pmf_qual_t *);
 static int	ihidev_hid_command(struct ihidev_softc *, int, void *, bool);
 static int	ihidev_intr(void *);
-static void	ihidev_softintr(void *);
+static void	ihidev_work(struct work *, void *);
 static int	ihidev_reset(struct ihidev_softc *, bool);
 static int	ihidev_hid_desc_parse(struct ihidev_softc *);
 static int	ihidev_maxrepid(void *, int);
 static int	ihidev_print(void *, const char *);
 static int	ihidev_submatch(device_t, cfdata_t, const int *, void *);
 static bool	ihidev_acpi_get_info(struct ihidev_softc *);
 static const struct device_compatible_entry compat_data[] = {
 	{ .compat = "PNP0C50" },
 	{ .compat = "ACPI0C50" },
 	{ .compat = "hid-over-i2c" },
 @@ -150,34 +150,34 @@ static void
 ihidev_attach(device_t parent, device_t self, void *aux)
+{
 	struct ihidev_softc *sc = device_private(self);
 	struct i2c_attach_args *ia = aux;
 	struct ihidev_attach_arg iha;
 	device_t dev;
 	int repid, repsz;
 	int isize;
 	int locs[IHIDBUSCF_NLOCS];
 	sc->sc_dev = self;
 	sc->sc_tag = ia->ia_tag;
 	sc->sc_addr = ia->ia_addr;
-	mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_VM);
+	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
 	sc->sc_phandle = ia->ia_cookie;
 	if (ia->ia_cookietype != I2C_COOKIE_ACPI) {
 		aprint_error(": unsupported device tree type\n");
 		return;
+	}
-	if (! ihidev_acpi_get_info(sc)) {
+	if (!ihidev_acpi_get_info(sc)) {
 		return;
+	}
 	if (ihidev_hid_command(sc, I2C_HID_CMD_DESCR, NULL, false) ||
 	    ihidev_hid_desc_parse(sc)) {
 		aprint_error(": failed fetching initial HID descriptor\n");
 		return;
+	}
 	aprint_naive("\n");
 	aprint_normal(": vendor 0x%x product 0x%x, %s\n",
 	    le16toh(sc->hid_desc.wVendorID), le16toh(sc->hid_desc.wProductID),
 	    ia->ia_name);
 @@ -198,27 +198,27 @@ ihidev_attach(device_t parent, device_t
 	for (repid = 0; repid < sc->sc_nrepid; repid++) {
 		repsz = hid_report_size(sc->sc_report, sc->sc_reportlen,
 		    hid_input, repid);
 		isize = repsz + 2; /* two bytes for the length */
 		isize += (sc->sc_nrepid != 1); /* one byte for the report ID */
 		if (isize > sc->sc_isize)
 			sc->sc_isize = isize;
 		DPRINTF(("%s: repid %d size %d\n", sc->sc_dev.dv_xname, repid,
 		    repsz));
+	}
 	sc->sc_ibuf = kmem_zalloc(sc->sc_isize, KM_SLEEP);
-	if (! ihiddev_intr_init(sc)) {
+	if (!ihidev_intr_init(sc)) {
 		return;
+	}
 	iha.iaa = ia;
 	iha.parent = sc;
 	/* Look for a driver claiming all report IDs first. */
 	iha.reportid = IHIDEV_CLAIM_ALLREPORTID;
 	locs[IHIDBUSCF_REPORTID] = IHIDEV_CLAIM_ALLREPORTID;
 	dev = config_found(self, &iha, ihidev_print,
 	    CFARGS(.submatch = ihidev_submatch,
 		   .locators = locs));
 	if (dev != NULL) {
 @@ -235,84 +235,92 @@ ihidev_attach(device_t parent, device_t
 		    hid_report_size(sc->sc_report, sc->sc_reportlen,
 		    hid_feature, repid) == 0)
 			continue;
 		iha.reportid = repid;
 		locs[IHIDBUSCF_REPORTID] = repid;
 		dev = config_found(self, &iha, ihidev_print,
 		    CFARGS(.submatch = ihidev_submatch,
 			   .locators = locs));
 		sc->sc_subdevs[repid] = device_private(dev);
+	}
 	/* power down until we're opened */
-	if (ihidev_hid_command(sc, I2C_HID_CMD_SET_POWER, &I2C_HID_POWER_OFF, false)) {
+	if (ihidev_hid_command(sc, I2C_HID_CMD_SET_POWER, &I2C_HID_POWER_OFF,
 		false)) {
 		aprint_error_dev(sc->sc_dev, "failed to power down\n");
 		return;
+	}
 	if (!pmf_device_register(self, ihidev_suspend, ihidev_resume))
 		aprint_error_dev(self, "couldn't establish power handler\n");
+}
 static int
 ihidev_detach(device_t self, int flags)
+{
 	struct ihidev_softc *sc = device_private(self);
 	int error;
 	error = config_detach_children(self, flags);
 	if (error)
 		return error;
 	pmf_device_deregister(self);
 	ihidev_intr_fini(sc);
 	if (ihidev_hid_command(sc, I2C_HID_CMD_SET_POWER, &I2C_HID_POWER_OFF,
 		true))
 		aprint_error_dev(sc->sc_dev, "failed to power down\n");
 	mutex_enter(&sc->sc_intr_lock);
 	ihiddev_intr_fini(sc);
 	if (ihidev_hid_command(sc, I2C_HID_CMD_SET_POWER,
 	    &I2C_HID_POWER_OFF, true))
 	aprint_error_dev(sc->sc_dev, "failed to power down\n");
 	mutex_exit(&sc->sc_intr_lock);
 	if (sc->sc_ibuf != NULL) {
 		kmem_free(sc->sc_ibuf, sc->sc_isize);
 		sc->sc_ibuf = NULL;
+	}
 	if (sc->sc_report != NULL)
 		kmem_free(sc->sc_report, sc->sc_reportlen);
-	pmf_device_deregister(self);
+	mutex_destroy(&sc->sc_lock);
 	return (0);
 	return 0;
+}
 static bool
 ihidev_suspend(device_t self, const pmf_qual_t *q)
+{
 	struct ihidev_softc *sc = device_private(self);
-	mutex_enter(&sc->sc_intr_lock);
+	mutex_enter(&sc->sc_lock);
 	if (sc->sc_refcnt > 0) {
 		printf("ihidev power off\n");
 		if (ihidev_hid_command(sc, I2C_HID_CMD_SET_POWER,
 		    &I2C_HID_POWER_OFF, true))
 		aprint_error_dev(sc->sc_dev, "failed to power down\n");
+	}
-	mutex_exit(&sc->sc_intr_lock);
+	mutex_exit(&sc->sc_lock);
 	return true;
+}
 static bool
 ihidev_resume(device_t self, const pmf_qual_t *q)
+{
 	struct ihidev_softc *sc = device_private(self);
-	mutex_enter(&sc->sc_intr_lock);
+	mutex_enter(&sc->sc_lock);
 	if (sc->sc_refcnt > 0) {
 		printf("ihidev power reset\n");
 		ihidev_reset(sc, true);
+	}
-	mutex_exit(&sc->sc_intr_lock);
+	mutex_exit(&sc->sc_lock);
 	return true;
+}
 static int
 ihidev_hid_command(struct ihidev_softc *sc, int hidcmd, void *arg, bool poll)
+{
 	int i, res = 1;
 	int flags = poll ? I2C_F_POLL : 0;
 	iic_acquire_bus(sc->sc_tag, flags);
 	switch (hidcmd) {
 	case I2C_HID_CMD_DESCR: {
 @@ -636,27 +644,27 @@ ihidev_hid_desc_parse(struct ihidev_soft
 	sc->sc_reportlen = le16toh(sc->hid_desc.wReportDescLength);
 	sc->sc_report = kmem_zalloc(sc->sc_reportlen, KM_NOSLEEP);
 	if (ihidev_hid_command(sc, I2C_HID_REPORT_DESCR, 0, false)) {
 		aprint_error_dev(sc->sc_dev, "failed fetching HID report\n");
 		return (1);
+	}
 	return (0);
+}
 static bool
-ihiddev_intr_init(struct ihidev_softc *sc)
+ihidev_intr_init(struct ihidev_softc *sc)
+{
 #if NACPICA > 0
 	ACPI_HANDLE hdl = (void *)(uintptr_t)sc->sc_phandle;
 	struct acpi_resources res;
 	ACPI_STATUS rv;
 	char buf[100];
 	rv = acpi_resource_parse(sc->sc_dev, hdl, "_CRS", &res,
 	    &acpi_resource_parse_ops_quiet);
 	if (ACPI_FAILURE(rv)) {
 		aprint_error_dev(sc->sc_dev, "can't parse '_CRS'\n");
 		return false;
+	}
 @@ -672,49 +680,50 @@ ihiddev_intr_init(struct ihidev_softc *s
 	    irq->ar_type == ACPI_EDGE_SENSITIVE ? IST_EDGE : IST_LEVEL;
 	acpi_resource_cleanup(&res);
 	sc->sc_ih = acpi_intr_establish(sc->sc_dev, sc->sc_phandle, IPL_TTY,
 	    false, ihidev_intr, sc, device_xname(sc->sc_dev));
 	if (sc->sc_ih == NULL) {
 		aprint_error_dev(sc->sc_dev, "can't establish interrupt\n");
 		return false;
+	}
 	aprint_normal_dev(sc->sc_dev, "interrupting at %s\n",
 	    acpi_intr_string(sc->sc_ih, buf, sizeof(buf)));
-	sc->sc_sih = softint_establish(SOFTINT_SERIAL, ihidev_softintr, sc);
+	if (workqueue_create(&sc->sc_wq, device_xname(sc->sc_dev), ihidev_work,
-	if (sc->sc_sih == NULL) {
+		sc, PRI_NONE, IPL_TTY, WQ_MPSAFE)) {
 		aprint_error_dev(sc->sc_dev,
-		    "can't establish soft interrupt\n");
+		    "can't establish workqueue\n");
 		return false;
+	}
 	sc->sc_work_pending = 0;
 	return true;
 #else
 	aprint_error_dev(sc->sc_dev, "can't establish interrupt\n");
 	return false;
 #endif
+}
 static void
-ihiddev_intr_fini(struct ihidev_softc *sc)
+ihidev_intr_fini(struct ihidev_softc *sc)
+{
 #if NACPICA > 0
 	if (sc->sc_ih != NULL) {
 		acpi_intr_disestablish(sc->sc_ih);
+	}
-	if (sc->sc_sih != NULL) {
+	if (sc->sc_wq != NULL) {
-		softint_disestablish(sc->sc_sih);
+		workqueue_destroy(sc->sc_wq);
+	}
 #endif
+}
 static void
 ihidev_intr_mask(struct ihidev_softc * const sc)
+{
 	if (sc->sc_intr_type == IST_LEVEL) {
 #if NACPICA > 0
 		acpi_intr_mask(sc->sc_ih);
 #endif
+	}
 @@ -726,58 +735,55 @@ ihidev_intr_unmask(struct ihidev_softc *
 	if (sc->sc_intr_type == IST_LEVEL) {
 #if NACPICA > 0
 		acpi_intr_unmask(sc->sc_ih);
 #endif
+	}
+}
 static int
 ihidev_intr(void *arg)
+{
 	struct ihidev_softc * const sc = arg;
 	mutex_enter(&sc->sc_intr_lock);
 	/*
-	 * Schedule our soft interrupt handler.  If we're using a level-
+	 * Schedule our work.  If we're using a level-triggered
-	 * triggered interrupt, we have to mask it off while we wait
+	 * interrupt, we have to mask it off while we wait for service.
 	 * for service.
 	 */
-	softint_schedule(sc->sc_sih);
+	if (atomic_swap_uint(&sc->sc_work_pending, 1) == 0)
 		workqueue_enqueue(sc->sc_wq, &sc->sc_work, NULL);
 	ihidev_intr_mask(sc);
 	mutex_exit(&sc->sc_intr_lock);
 	return 1;
+}
 static void
-ihidev_softintr(void *arg)
+ihidev_work(struct work *wk, void *arg)
+{
 	struct ihidev_softc * const sc = arg;
 	struct ihidev *scd;
 	u_int psize;
 	int res, i;
 	u_char *p;
 	u_int rep = 0;
-	mutex_enter(&sc->sc_intr_lock);
+	atomic_store_relaxed(&sc->sc_work_pending, 0);
 	mutex_enter(&sc->sc_lock);
 	iic_acquire_bus(sc->sc_tag, 0);
 	res = iic_exec(sc->sc_tag, I2C_OP_READ_WITH_STOP, sc->sc_addr, NULL, 0,
 	    sc->sc_ibuf, sc->sc_isize, 0);
 	iic_release_bus(sc->sc_tag, 0);
 	mutex_exit(&sc->sc_intr_lock);
 	if (res != 0)
 		goto out;
 	/*
 	 * 6.1.1 - First two bytes are the packet length, which must be less
 	 * than or equal to wMaxInputLength
 	 */
 	psize = sc->sc_ibuf[0] | sc->sc_ibuf[1] << 8;
 	if (!psize || psize > sc->sc_isize) {
 		DPRINTF(("%s: %s: invalid packet size (%d vs. %d)\n",
 		    sc->sc_dev.dv_xname, __func__, psize, sc->sc_isize));
 		goto out;
+	}
 @@ -797,26 +803,28 @@ ihidev_softintr(void *arg)
 	DPRINTF(("%s: %s: hid input (rep %d):", sc->sc_dev.dv_xname,
 	    __func__, rep));
 	for (i = 0; i < sc->sc_isize; i++)
 		DPRINTF((" %.2x", sc->sc_ibuf[i]));
 	DPRINTF(("\n"));
 	scd = sc->sc_subdevs[rep];
 	if (scd == NULL || !(scd->sc_state & IHIDEV_OPEN))
 		goto out;
 	scd->sc_intr(scd, p, psize);
  out:
 	mutex_exit(&sc->sc_lock);
 	/*
 	 * If our interrupt is level-triggered, re-enable it now.
 	 */
 	ihidev_intr_unmask(sc);
+}
 static int
 ihidev_maxrepid(void *buf, int len)
+{
 	struct hid_data *d;
 	struct hid_item h;
 	int maxid;
 @@ -827,27 +835,27 @@ ihidev_maxrepid(void *buf, int len)
 			maxid = h.report_ID;
 	hid_end_parse(d);
 	return (maxid);
+}
 static int
 ihidev_print(void *aux, const char *pnp)
+{
 	struct ihidev_attach_arg *iha = aux;
 	if (iha->reportid == IHIDEV_CLAIM_ALLREPORTID)
 		return (QUIET);
 	if (pnp)
 		aprint_normal("hid at %s", pnp);
 	if (iha->reportid != 0)
 		aprint_normal(" reportid %d", iha->reportid);
 	return (UNCONF);
+}
 static int
 ihidev_submatch(device_t parent, cfdata_t cf, const int *locs, void *aux)
+{
 	struct ihidev_attach_arg *iha = aux;
 @@ -964,27 +972,27 @@ ihidev_set_report(struct device *dev, in
 	rreq.data = data;
 	rreq.len = len;
 	if (ihidev_hid_command(sc, I2C_HID_CMD_SET_REPORT, &rreq, false)) {
 		aprint_error_dev(sc->sc_dev, "failed setting report\n");
 		return (1);
+	}
 	return 0;
+}
 static bool
 ihidev_acpi_get_info(struct ihidev_softc *sc)
+{
 	ACPI_HANDLE hdl = (void *)(uintptr_t)sc->sc_phandle;
 	ACPI_STATUS status;
 	ACPI_INTEGER val;
 	/* 3cdff6f7-4267-4555-ad05-b30a3d8938de */
 	uint8_t i2c_hid_guid[] = {
 xF7, 0xF6, 0xDF, 0x3C,
 x67, 0x42,
 x55, 0x45,
 xAD, 0x05,
 xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE,
 	};

 @@ -1,14 +1,14 @@
-/* $NetBSD: ihidev.h,v 1.5 2022/01/14 21:32:27 riastradh Exp $ */
+/* $NetBSD: ihidev.h,v 1.6 2022/01/14 22:25:49 riastradh Exp $ */
 /* $OpenBSD ihidev.h,v 1.4 2016/01/31 18:24:35 jcs 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
 @@ -96,38 +96,41 @@ struct i2c_hid_desc {
 	uint16_t wDataRegister;
 	uint16_t wVendorID;
 	uint16_t wProductID;
 	uint16_t wVersionID;
 	uint32_t reserved;
 } __packed;
 /* ihidevvar.h */
 #include <sys/types.h>
 #include <sys/device.h>
 #include <sys/mutex.h>
 #include <sys/workqueue.h>
 #include <dev/i2c/i2cvar.h>
 struct ihidev_softc {
 	device_t	sc_dev;
 	i2c_tag_t	sc_tag;
 	i2c_addr_t	sc_addr;
 	uint64_t	sc_phandle;
 	kmutex_t	sc_lock;
 	void *		sc_ih;
-	void *		sc_sih;
+	struct workqueue *sc_wq;
-	kmutex_t	sc_intr_lock;
+	struct work	sc_work;
 	volatile unsigned sc_work_pending;
 	int		sc_intr_type;
 	u_int		sc_hid_desc_addr;
 	union {
 		uint8_t	hid_desc_buf[sizeof(struct i2c_hid_desc)];
 		struct i2c_hid_desc hid_desc;
 	};
 	uint8_t		*sc_report;
 	int		sc_reportlen;
 	int		sc_nrepid;
 	struct		ihidev **sc_subdevs;