ums.c revision 1.105
1 /* $NetBSD: ums.c,v 1.105 2024/01/13 15:26:36 hgutch 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 (at) 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.105 2024/01/13 15:26:36 hgutch 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 77 static int umsdebug = UMS_DEBUG_DEFAULT; 78 79 SYSCTL_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; 102 fail: 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 120 struct 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 131 Static void ums_intr(void *, void *, u_int); 132 133 Static int ums_enable(void *); 134 Static void ums_disable(void *); 135 Static int ums_ioctl(void *, u_long, void *, int, struct lwp *); 136 137 static const struct wsmouse_accessops ums_accessops = { 138 ums_enable, 139 ums_ioctl, 140 ums_disable, 141 }; 142 143 static int ums_match(device_t, cfdata_t, void *); 144 static void ums_attach(device_t, device_t, void *); 145 static void ums_childdet(device_t, device_t); 146 static int ums_detach(device_t, int); 147 static int ums_activate(device_t, enum devact); 148 149 CFATTACH_DECL2_NEW(ums, sizeof(struct ums_softc), ums_match, ums_attach, 150 ums_detach, ums_activate, NULL, ums_childdet); 151 152 static int 153 ums_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, 0x0002))) 174 return UMATCH_NONE; 175 176 return UMATCH_IFACECLASS; 177 } 178 179 static void 180 ums_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 291 static int 292 ums_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 305 static void 306 ums_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 314 static int 315 ums_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 336 Static void 337 ums_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 345 Static int 346 ums_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 371 Static void 372 ums_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 392 Static int 393 ums_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
Indexes created Mon Sep 29 13:09:55 GMT 2025