xref: /freebsd/sys/dev/hid/hconf.c (revision dc318a4ffabcbfa23bb56a33403aad36e6de30af)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2019 Vladimir Kondratyev <wulf@FreeBSD.org>
5  * Copyright (c) 2020 Andriy Gapon <avg@FreeBSD.org>
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26  * SUCH DAMAGE.
27  */
28 
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
31 
32 /*
33  * Digitizer configuration top-level collection support.
34  * https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-precision-touchpad-required-hid-top-level-collections
35  */
36 
37 #include "opt_hid.h"
38 
39 #include <sys/param.h>
40 #include <sys/bus.h>
41 #include <sys/kernel.h>
42 #include <sys/lock.h>
43 #include <sys/malloc.h>
44 #include <sys/module.h>
45 #include <sys/sysctl.h>
46 #include <sys/systm.h>
47 #include <sys/sx.h>
48 
49 #define	HID_DEBUG_VAR	hconf_debug
50 #include <dev/hid/hid.h>
51 #include <dev/hid/hidbus.h>
52 
53 #include <dev/hid/hconf.h>
54 
55 #ifdef HID_DEBUG
56 static int hconf_debug = 0;
57 
58 static SYSCTL_NODE(_hw_hid, OID_AUTO, hconf, CTLFLAG_RW, 0,
59     "Digitizer configuration top-level collection");
60 SYSCTL_INT(_hw_hid_hconf, OID_AUTO, debug, CTLFLAG_RWTUN,
61     &hconf_debug, 1, "Debug level");
62 #endif
63 
64 enum feature_control_type {
65 	INPUT_MODE = 0,
66 	SURFACE_SWITCH,
67 	BUTTONS_SWITCH,
68 	CONTROLS_COUNT
69 };
70 
71 struct feature_control_descr {
72 	const char	*name;
73 	const char	*descr;
74 	uint16_t	usage;
75 	u_int		value;
76 } feature_control_descrs[] = {
77 	[INPUT_MODE] = {
78 		.name = "input_mode",
79 		.descr = "HID device input mode: 0 = mouse, 3 = touchpad",
80 		.usage = HUD_INPUT_MODE,
81 		.value = HCONF_INPUT_MODE_MOUSE,
82 	},
83 	[SURFACE_SWITCH] = {
84 		.name = "surface_switch",
85 		.descr = "Enable / disable switch for surface: 1 = on, 0 = off",
86 		.usage = HUD_SURFACE_SWITCH,
87 		.value = 1,
88 	},
89 	[BUTTONS_SWITCH] = {
90 		.name = "buttons_switch",
91 		.descr = "Enable / disable switch for buttons: 1 = on, 0 = off",
92 		.usage = HUD_BUTTONS_SWITCH,
93 		.value = 1,
94 	},
95 };
96 
97 struct feature_control {
98 	u_int			val;
99 	struct hid_location	loc;
100 	hid_size_t		rlen;
101 	uint8_t			rid;
102 };
103 
104 struct hconf_softc {
105 	device_t		dev;
106 	struct sx		lock;
107 
108 	struct feature_control	feature_controls[CONTROLS_COUNT];
109 };
110 
111 static device_probe_t		hconf_probe;
112 static device_attach_t		hconf_attach;
113 static device_detach_t		hconf_detach;
114 static device_resume_t		hconf_resume;
115 
116 static devclass_t hconf_devclass;
117 
118 static device_method_t hconf_methods[] = {
119 
120 	DEVMETHOD(device_probe,		hconf_probe),
121 	DEVMETHOD(device_attach,	hconf_attach),
122 	DEVMETHOD(device_detach,	hconf_detach),
123 	DEVMETHOD(device_resume,	hconf_resume),
124 
125 	DEVMETHOD_END
126 };
127 
128 static driver_t hconf_driver = {
129 	.name = "hconf",
130 	.methods = hconf_methods,
131 	.size = sizeof(struct hconf_softc),
132 };
133 
134 static const struct hid_device_id hconf_devs[] = {
135 	{ HID_TLC(HUP_DIGITIZERS, HUD_CONFIG) },
136 };
137 
138 static int
139 hconf_set_feature_control(struct hconf_softc *sc, int ctrl_id, u_int val)
140 {
141 	struct feature_control *fc;
142 	uint8_t *fbuf;
143 	int error;
144 	int i;
145 
146 	KASSERT(ctrl_id >= 0 && ctrl_id < CONTROLS_COUNT,
147 	    ("impossible ctrl id %d", ctrl_id));
148 	fc = &sc->feature_controls[ctrl_id];
149 	if (fc->rlen <= 1)
150 		return (ENXIO);
151 
152 	fbuf = malloc(fc->rlen, M_TEMP, M_WAITOK | M_ZERO);
153 	sx_xlock(&sc->lock);
154 
155 	/*
156 	 * Assume the report is write-only. Then we have to check for other
157 	 * controls that may share the same report and set their bits as well.
158 	 */
159 	bzero(fbuf + 1, fc->rlen - 1);
160 	for (i = 0; i < nitems(sc->feature_controls); i++) {
161 		struct feature_control *ofc = &sc->feature_controls[i];
162 
163 		/* Skip unrelated report IDs. */
164 		if (ofc->rid != fc->rid)
165 			continue;
166 		KASSERT(fc->rlen == ofc->rlen,
167 		    ("different lengths for report %d: %d vs %d\n",
168 		    fc->rid, fc->rlen, ofc->rlen));
169 		hid_put_udata(fbuf + 1, ofc->rlen - 1, &ofc->loc,
170 		    i == ctrl_id ? val : ofc->val);
171 	}
172 
173 	fbuf[0] = fc->rid;
174 
175 	error = hid_set_report(sc->dev, fbuf, fc->rlen,
176 	    HID_FEATURE_REPORT, fc->rid);
177 	if (error == 0)
178 		fc->val = val;
179 
180 	sx_unlock(&sc->lock);
181 	free(fbuf, M_TEMP);
182 
183 	return (error);
184 }
185 
186 static int
187 hconf_feature_control_handler(SYSCTL_HANDLER_ARGS)
188 {
189 	struct feature_control *fc;
190 	struct hconf_softc *sc = arg1;
191 	int ctrl_id = arg2;
192 	u_int value;
193 	int error;
194 
195 	if (ctrl_id < 0 || ctrl_id >= CONTROLS_COUNT)
196 		return (ENXIO);
197 
198 	fc = &sc->feature_controls[ctrl_id];
199 	value = fc->val;
200 	error = sysctl_handle_int(oidp, &value, 0, req);
201 	if (error != 0 || req->newptr == NULL)
202 		return (error);
203 
204 	error = hconf_set_feature_control(sc, ctrl_id, value);
205 	if (error != 0) {
206 		DPRINTF("Failed to set %s: %d\n",
207 		    feature_control_descrs[ctrl_id].name, error);
208 	}
209 	return (0);
210 }
211 
212 
213 static int
214 hconf_parse_feature(struct feature_control *fc, uint8_t tlc_index,
215     uint16_t usage, void *d_ptr, hid_size_t d_len)
216 {
217 	uint32_t flags;
218 
219 	if (!hidbus_locate(d_ptr, d_len, HID_USAGE2(HUP_DIGITIZERS, usage),
220 	    hid_feature, tlc_index, 0, &fc->loc, &flags, &fc->rid, NULL))
221 		return (ENOENT);
222 
223 	if ((flags & (HIO_VARIABLE | HIO_RELATIVE)) != HIO_VARIABLE)
224 		return (EINVAL);
225 
226 	fc->rlen = hid_report_size(d_ptr, d_len, hid_feature, fc->rid);
227 	return (0);
228 }
229 
230 static int
231 hconf_probe(device_t dev)
232 {
233 	int error;
234 
235 	error = HIDBUS_LOOKUP_DRIVER_INFO(dev, hconf_devs);
236 	if (error != 0)
237 		return (error);
238 
239 	hidbus_set_desc(dev, "Configuration");
240 
241 	return (BUS_PROBE_DEFAULT);
242 }
243 
244 static int
245 hconf_attach(device_t dev)
246 {
247 	struct hconf_softc *sc = device_get_softc(dev);
248 	struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
249 	struct sysctl_oid *tree = device_get_sysctl_tree(dev);
250 	void *d_ptr;
251 	hid_size_t d_len;
252 	uint8_t tlc_index;
253 	int error;
254 	int i;
255 
256 	error = hid_get_report_descr(dev, &d_ptr, &d_len);
257 	if (error) {
258 		device_printf(dev, "could not retrieve report descriptor from "
259 		    "device: %d\n", error);
260 		return (ENXIO);
261 	}
262 
263 	sc->dev = dev;
264 	sx_init(&sc->lock, device_get_nameunit(dev));
265 
266 	tlc_index = hidbus_get_index(dev);
267 	for (i = 0; i < nitems(sc->feature_controls); i++) {
268 		(void)hconf_parse_feature(&sc->feature_controls[i], tlc_index,
269 		    feature_control_descrs[i].usage, d_ptr, d_len);
270 		if (sc->feature_controls[i].rlen > 1) {
271 			SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
272 			    feature_control_descrs[i].name,
273 			    CTLTYPE_UINT | CTLFLAG_RW,
274 			    sc, i, hconf_feature_control_handler, "I",
275 			    feature_control_descrs[i].descr);
276 		}
277 		sc->feature_controls[i].val = feature_control_descrs[i].value;
278 	}
279 
280 	return (0);
281 }
282 
283 static int
284 hconf_detach(device_t dev)
285 {
286 	struct hconf_softc *sc = device_get_softc(dev);
287 
288 	sx_destroy(&sc->lock);
289 
290 	return (0);
291 }
292 
293 static int
294 hconf_resume(device_t dev)
295 {
296 	struct hconf_softc *sc = device_get_softc(dev);
297 	int error;
298 	int i;
299 
300 	for (i = 0; i < nitems(sc->feature_controls); i++) {
301 		if (sc->feature_controls[i].rlen < 2)
302 			continue;
303 		/* Do not update usages to default value */
304 		if (sc->feature_controls[i].val ==
305 		    feature_control_descrs[i].value)
306 			continue;
307 		error = hconf_set_feature_control(sc, i,
308 		    sc->feature_controls[i].val);
309 		if (error != 0) {
310 			DPRINTF("Failed to restore %s: %d\n",
311 			    feature_control_descrs[i].name, error);
312 		}
313 	}
314 
315 	return (0);
316 }
317 
318 int
319 hconf_set_input_mode(device_t dev, enum hconf_input_mode mode)
320 {
321 	struct hconf_softc *sc = device_get_softc(dev);
322 
323 	return (hconf_set_feature_control(sc, INPUT_MODE, mode));
324 }
325 
326 DRIVER_MODULE(hconf, hidbus, hconf_driver, hconf_devclass, NULL, 0);
327 MODULE_DEPEND(hconf, hidbus, 1, 1, 1);
328 MODULE_DEPEND(hconf, hid, 1, 1, 1);
329 MODULE_VERSION(hconf, 1);
330 HID_PNP_INFO(hconf_devs);
331