1/*	$NetBSD: ums.c,v 1.106 2024/03/18 15:15:27 jakllsch Exp $	*/
2
3/*
4 * Copyright (c) 1998, 2017 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Lennart Augustsson (lennart@augustsson.net) at
9 * Carlstedt Research & Technology.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 *    notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 *    notice, this list of conditions and the following disclaimer in the
18 *    documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33/*
34 * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf
35 */
36
37#include <sys/cdefs.h>
38__KERNEL_RCSID(0, "$NetBSD: ums.c,v 1.106 2024/03/18 15:15:27 jakllsch Exp $");
39
40#ifdef _KERNEL_OPT
41#include "opt_usb.h"
42#endif
43
44#include <sys/param.h>
45#include <sys/systm.h>
46#include <sys/kernel.h>
47#include <sys/device.h>
48#include <sys/ioctl.h>
49#include <sys/file.h>
50#include <sys/select.h>
51#include <sys/sysctl.h>
52#include <sys/proc.h>
53#include <sys/vnode.h>
54#include <sys/poll.h>
55
56#include <dev/usb/usb.h>
57#include <dev/usb/usbhid.h>
58
59#include <dev/usb/usbdi.h>
60#include <dev/usb/usbdi_util.h>
61#include <dev/usb/usbdevs.h>
62#include <dev/usb/usb_quirks.h>
63#include <dev/usb/uhidev.h>
64#include <dev/usb/usbhist.h>
65#include <dev/hid/hid.h>
66#include <dev/hid/hidms.h>
67
68#ifdef USB_DEBUG
69#ifndef UMS_DEBUG
70#define umsdebug 0
71#else
72
73#ifndef UMS_DEBUG_DEFAULT
74#define UMS_DEBUG_DEFAULT 0
75#endif
76
77static int umsdebug = UMS_DEBUG_DEFAULT;
78
79SYSCTL_SETUP(sysctl_hw_ums_setup, "sysctl hw.ums setup")
80{
81	int err;
82	const struct sysctlnode *rnode;
83	const struct sysctlnode *cnode;
84
85	err = sysctl_createv(clog, 0, NULL, &rnode,
86	    CTLFLAG_PERMANENT, CTLTYPE_NODE, "ums",
87	    SYSCTL_DESCR("ums global controls"),
88	    NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL);
89
90	if (err)
91		goto fail;
92
93	/* control debugging printfs */
94	err = sysctl_createv(clog, 0, &rnode, &cnode,
95	    CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT,
96	    "debug", SYSCTL_DESCR("Enable debugging output"),
97	    NULL, 0, &umsdebug, sizeof(umsdebug), CTL_CREATE, CTL_EOL);
98	if (err)
99		goto fail;
100
101	return;
102fail:
103	aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err);
104}
105
106#endif /* UMS_DEBUG */
107#endif /* USB_DEBUG */
108
109#define DPRINTF(FMT,A,B,C,D)	USBHIST_LOGN(umsdebug,1,FMT,A,B,C,D)
110#define DPRINTFN(N,FMT,A,B,C,D)	USBHIST_LOGN(umsdebug,N,FMT,A,B,C,D)
111#define UMSHIST_FUNC()		USBHIST_FUNC()
112#define UMSHIST_CALLED(name)	USBHIST_CALLED(umsdebug)
113#define UMSHIST_CALLARGS(FMT,A,B,C,D) \
114				USBHIST_CALLARGS(umsdebug,FMT,A,B,C,D)
115#define UMSHIST_CALLARGSN(N,FMT,A,B,C,D) \
116				USBHIST_CALLARGSN(umsdebug,N,FMT,A,B,C,D)
117
118#define UMSUNIT(s)	(minor(s))
119
120struct ums_softc {
121	struct uhidev *sc_hdev;
122	struct usbd_device *sc_udev;
123	struct hidms sc_ms;
124
125	bool	sc_alwayson;
126
127	int	sc_enabled;
128	char	sc_dying;
129};
130
131Static void ums_intr(void *, void *, u_int);
132
133Static int	ums_enable(void *);
134Static void	ums_disable(void *);
135Static int	ums_ioctl(void *, u_long, void *, int, struct lwp *);
136
137static const struct wsmouse_accessops ums_accessops = {
138	ums_enable,
139	ums_ioctl,
140	ums_disable,
141};
142
143static int ums_match(device_t, cfdata_t, void *);
144static void ums_attach(device_t, device_t, void *);
145static void ums_childdet(device_t, device_t);
146static int ums_detach(device_t, int);
147static int ums_activate(device_t, enum devact);
148
149CFATTACH_DECL2_NEW(ums, sizeof(struct ums_softc), ums_match, ums_attach,
150    ums_detach, ums_activate, NULL, ums_childdet);
151
152static int
153ums_match(device_t parent, cfdata_t match, void *aux)
154{
155	struct uhidev_attach_arg *uha = aux;
156	int size;
157	void *desc;
158
159	/*
160	 * Some (older) Griffin PowerMate knobs may masquerade as a
161	 * mouse, avoid treating them as such, they have only one axis.
162	 */
163	if (uha->uiaa->uiaa_vendor == USB_VENDOR_GRIFFIN &&
164	    uha->uiaa->uiaa_product == USB_PRODUCT_GRIFFIN_POWERMATE)
165		return UMATCH_NONE;
166
167	uhidev_get_report_desc(uha->parent, &desc, &size);
168	if (!hid_is_collection(desc, size, uha->reportid,
169			       HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_MOUSE)) &&
170	    !hid_is_collection(desc, size, uha->reportid,
171			       HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_POINTER)) &&
172	    !hid_is_collection(desc, size, uha->reportid,
173			       HID_USAGE2(HUP_DIGITIZERS, HUD_PEN)))
174		return UMATCH_NONE;
175
176	return UMATCH_IFACECLASS;
177}
178
179static void
180ums_attach(device_t parent, device_t self, void *aux)
181{
182	struct ums_softc *sc = device_private(self);
183	struct uhidev_attach_arg *uha = aux;
184	struct hid_data *d;
185	struct hid_item item;
186	int size, error;
187	void *desc;
188	uint32_t quirks;
189
190	aprint_naive("\n");
191
192	sc->sc_hdev = uha->parent;
193	sc->sc_udev = uha->uiaa->uiaa_device;
194
195	quirks = usbd_get_quirks(sc->sc_udev)->uq_flags;
196	if (quirks & UQ_MS_REVZ)
197		sc->sc_ms.flags |= HIDMS_REVZ;
198	if (quirks & UQ_SPUR_BUT_UP)
199		sc->sc_ms.flags |= HIDMS_SPUR_BUT_UP;
200	if (quirks & UQ_ALWAYS_ON)
201		sc->sc_alwayson = true;
202
203	if (!pmf_device_register(self, NULL, NULL))
204		aprint_error_dev(self, "couldn't establish power handler\n");
205
206	uhidev_get_report_desc(uha->parent, &desc, &size);
207
208	if (!hidms_setup(self, &sc->sc_ms, uha->reportid, desc, size))
209		return;
210
211	if (uha->uiaa->uiaa_vendor == USB_VENDOR_MICROSOFT) {
212		int fixpos;
213		int woffset = 8;
214		/*
215		 * The Microsoft Wireless Laser Mouse 6000 v2.0 and the
216		 * Microsoft Comfort Mouse 2.0 report a bad position for
217		 * the wheel and wheel tilt controls -- should be in bytes
218		 * 3 & 4 of the report. Fix this if necessary.
219		 */
220		switch (uha->uiaa->uiaa_product) {
221		case USB_PRODUCT_MICROSOFT_24GHZ_XCVR10:
222		case USB_PRODUCT_MICROSOFT_24GHZ_XCVR20:
223		case USB_PRODUCT_MICROSOFT_NATURAL_6000:
224			fixpos = 24;
225			break;
226		case USB_PRODUCT_MICROSOFT_24GHZ_XCVR80:
227		case USB_PRODUCT_MICROSOFT_24GHZ_XCVR90:
228			fixpos = 40;
229			woffset = sc->sc_ms.hidms_loc_z.size;
230			break;
231		case USB_PRODUCT_MICROSOFT_CM6000:
232			fixpos = 40;
233			break;
234		default:
235			fixpos = 0;
236			break;
237		}
238		if (fixpos) {
239			if ((sc->sc_ms.flags & HIDMS_Z) &&
240			    sc->sc_ms.hidms_loc_z.pos == 0)
241				sc->sc_ms.hidms_loc_z.pos = fixpos;
242			if ((sc->sc_ms.flags & HIDMS_W) &&
243			    sc->sc_ms.hidms_loc_w.pos == 0)
244				sc->sc_ms.hidms_loc_w.pos =
245				    sc->sc_ms.hidms_loc_z.pos + woffset;
246		}
247	}
248
249	tpcalib_init(&sc->sc_ms.sc_tpcalib);
250
251	/* calibrate the pointer if it reports absolute events */
252	if (sc->sc_ms.flags & HIDMS_ABS) {
253		memset(&sc->sc_ms.sc_calibcoords, 0, sizeof(sc->sc_ms.sc_calibcoords));
254		sc->sc_ms.sc_calibcoords.maxx = 0;
255		sc->sc_ms.sc_calibcoords.maxy = 0;
256		sc->sc_ms.sc_calibcoords.samplelen = WSMOUSE_CALIBCOORDS_RESET;
257		d = hid_start_parse(desc, size, hid_input);
258		if (d != NULL) {
259			while (hid_get_item(d, &item)) {
260				if (item.kind != hid_input
261				    || HID_GET_USAGE_PAGE(item.usage) != HUP_GENERIC_DESKTOP
262				    || item.report_ID != uha->reportid)
263					continue;
264				if (HID_GET_USAGE(item.usage) == HUG_X) {
265					sc->sc_ms.sc_calibcoords.minx = item.logical_minimum;
266					sc->sc_ms.sc_calibcoords.maxx = item.logical_maximum;
267				}
268				if (HID_GET_USAGE(item.usage) == HUG_Y) {
269					sc->sc_ms.sc_calibcoords.miny = item.logical_minimum;
270					sc->sc_ms.sc_calibcoords.maxy = item.logical_maximum;
271				}
272			}
273			hid_end_parse(d);
274		}
275        	tpcalib_ioctl(&sc->sc_ms.sc_tpcalib, WSMOUSEIO_SCALIBCOORDS,
276        	    (void *)&sc->sc_ms.sc_calibcoords, 0, 0);
277	}
278
279	hidms_attach(self, &sc->sc_ms, &ums_accessops);
280
281	if (sc->sc_alwayson) {
282		error = uhidev_open(sc->sc_hdev, &ums_intr, sc);
283		if (error != 0) {
284			aprint_error_dev(self,
285			    "WARNING: couldn't open always-on device\n");
286			sc->sc_alwayson = false;
287		}
288	}
289}
290
291static int
292ums_activate(device_t self, enum devact act)
293{
294	struct ums_softc *sc = device_private(self);
295
296	switch (act) {
297	case DVACT_DEACTIVATE:
298		sc->sc_dying = 1;
299		return 0;
300	default:
301		return EOPNOTSUPP;
302	}
303}
304
305static void
306ums_childdet(device_t self, device_t child)
307{
308	struct ums_softc *sc = device_private(self);
309
310	KASSERT(sc->sc_ms.hidms_wsmousedev == child);
311	sc->sc_ms.hidms_wsmousedev = NULL;
312}
313
314static int
315ums_detach(device_t self, int flags)
316{
317	struct ums_softc *sc = device_private(self);
318	int rv = 0;
319
320	UMSHIST_FUNC();
321	UMSHIST_CALLARGS("ums_detach: sc=%qd flags=%qd\n",
322	    (uintptr_t)sc, flags, 0, 0);
323
324	if (sc->sc_alwayson)
325		uhidev_close(sc->sc_hdev);
326
327	/* No need to do reference counting of ums, wsmouse has all the goo. */
328	if (sc->sc_ms.hidms_wsmousedev != NULL)
329		rv = config_detach(sc->sc_ms.hidms_wsmousedev, flags);
330
331	pmf_device_deregister(self);
332
333	return rv;
334}
335
336Static void
337ums_intr(void *cookie, void *ibuf, u_int len)
338{
339	struct ums_softc *sc = cookie;
340
341	if (sc->sc_enabled)
342		hidms_intr(&sc->sc_ms, ibuf, len);
343}
344
345Static int
346ums_enable(void *v)
347{
348	struct ums_softc *sc = v;
349	int error = 0;
350
351	UMSHIST_FUNC(); UMSHIST_CALLARGS("sc=%jx\n", (uintptr_t)sc, 0, 0, 0);
352
353	if (sc->sc_dying)
354		return EIO;
355
356	if (sc->sc_enabled)
357		return EBUSY;
358
359	sc->sc_enabled = 1;
360	sc->sc_ms.hidms_buttons = 0;
361
362	if (!sc->sc_alwayson) {
363		error = uhidev_open(sc->sc_hdev, &ums_intr, sc);
364		if (error)
365			sc->sc_enabled = 0;
366	}
367
368	return error;
369}
370
371Static void
372ums_disable(void *v)
373{
374	struct ums_softc *sc = v;
375
376	UMSHIST_FUNC(); UMSHIST_CALLARGS("sc=%jx\n", (uintptr_t)sc, 0, 0, 0);
377
378#ifdef DIAGNOSTIC
379	if (!sc->sc_enabled) {
380		printf("ums_disable: not enabled\n");
381		return;
382	}
383#endif
384
385	if (sc->sc_enabled) {
386		sc->sc_enabled = 0;
387		if (!sc->sc_alwayson)
388			uhidev_close(sc->sc_hdev);
389	}
390}
391
392Static int
393ums_ioctl(void *v, u_long cmd, void *data, int flag,
394    struct lwp *l)
395
396{
397	struct ums_softc *sc = v;
398	int error;
399
400	if (sc->sc_ms.flags & HIDMS_ABS) {
401		error = tpcalib_ioctl(&sc->sc_ms.sc_tpcalib, cmd, data,
402		    flag, l);
403		if (error != EPASSTHROUGH)
404			return error;
405	}
406
407	switch (cmd) {
408	case WSMOUSEIO_GTYPE:
409		if (sc->sc_ms.flags & HIDMS_ABS)
410			*(u_int *)data = WSMOUSE_TYPE_TPANEL;
411		else
412			*(u_int *)data = WSMOUSE_TYPE_USB;
413		return 0;
414	}
415
416	return EPASSTHROUGH;
417}
418