1 /* $NetBSD: uts.c,v 1.18 2025/04/07 11:13:15 hans Exp $ */ 2 3 /* 4 * Copyright (c) 2012 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Pierre Pronchery (khorben (at) defora.org). 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /* 33 * USB generic Touch Screen driver. 34 */ 35 36 #include <sys/cdefs.h> 37 __KERNEL_RCSID(0, "$NetBSD: uts.c,v 1.18 2025/04/07 11:13:15 hans Exp $"); 38 39 #ifdef _KERNEL_OPT 40 #include "opt_usb.h" 41 #endif 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/kernel.h> 46 #include <sys/device.h> 47 #include <sys/ioctl.h> 48 #include <sys/vnode.h> 49 50 #include <dev/usb/usb.h> 51 #include <dev/usb/usbhid.h> 52 53 #include <dev/usb/usbdi.h> 54 #include <dev/usb/usbdi_util.h> 55 #include <dev/usb/usbdevs.h> 56 #include <dev/usb/usb_quirks.h> 57 #include <dev/usb/uhidev.h> 58 #include <dev/hid/hid.h> 59 60 #include <dev/wscons/wsconsio.h> 61 #include <dev/wscons/wsmousevar.h> 62 #include <dev/wscons/tpcalibvar.h> 63 64 #ifdef UTS_DEBUG 65 #define DPRINTF(x) if (utsdebug) printf x 66 #define DPRINTFN(n,x) if (utsdebug>(n)) printf x 67 int utsdebug = 0; 68 #else 69 #define DPRINTF(x) 70 #define DPRINTFN(n,x) 71 #endif 72 73 74 struct uts_softc { 75 device_t sc_dev; 76 struct uhidev *sc_hdev; 77 78 struct hid_location sc_loc_x, sc_loc_y, sc_loc_z; 79 struct hid_location sc_loc_btn; 80 81 int sc_enabled; 82 83 int flags; /* device configuration */ 84 #define UTS_ABS 0x1 /* absolute position */ 85 86 uint32_t sc_buttons; /* touchscreen button status */ 87 device_t sc_wsmousedev; 88 struct tpcalib_softc sc_tpcalib; /* calibration */ 89 struct wsmouse_calibcoords sc_calibcoords; 90 91 char sc_dying; 92 }; 93 94 #define TSCREEN_FLAGS_MASK (HIO_CONST|HIO_RELATIVE) 95 96 Static void uts_intr(void *, void *, u_int); 97 98 Static int uts_enable(void *); 99 Static void uts_disable(void *); 100 Static int uts_ioctl(void *, u_long, void *, int, struct lwp *); 101 102 Static const struct wsmouse_accessops uts_accessops = { 103 uts_enable, 104 uts_ioctl, 105 uts_disable, 106 }; 107 108 Static int uts_match(device_t, cfdata_t, void *); 109 Static void uts_attach(device_t, device_t, void *); 110 Static void uts_childdet(device_t, device_t); 111 Static int uts_detach(device_t, int); 112 Static int uts_activate(device_t, enum devact); 113 114 115 116 CFATTACH_DECL2_NEW(uts, sizeof(struct uts_softc), uts_match, uts_attach, 117 uts_detach, uts_activate, NULL, uts_childdet); 118 119 Static int 120 uts_match(device_t parent, cfdata_t match, void *aux) 121 { 122 struct uhidev_attach_arg *uha = aux; 123 int size; 124 void *desc; 125 126 uhidev_get_report_desc(uha->parent, &desc, &size); 127 if (!hid_is_collection(desc, size, uha->reportid, 128 HID_USAGE2(HUP_DIGITIZERS, HUD_TOUCH_SCREEN)) && 129 !hid_is_collection(desc, size, uha->reportid, 130 HID_USAGE2(HUP_DIGITIZERS, HUD_FINGER))) 131 return UMATCH_NONE; 132 133 return UMATCH_IFACECLASS; 134 } 135 136 Static void 137 uts_attach(device_t parent, device_t self, void *aux) 138 { 139 struct uts_softc *sc = device_private(self); 140 struct uhidev_attach_arg *uha = aux; 141 struct wsmousedev_attach_args a; 142 int size; 143 void *desc; 144 uint32_t flags; 145 struct hid_data * d; 146 struct hid_item item; 147 148 aprint_normal("\n"); 149 150 sc->sc_dev = self; 151 sc->sc_hdev = uha->parent; 152 153 uhidev_get_report_desc(uha->parent, &desc, &size); 154 155 if (!pmf_device_register(self, NULL, NULL)) 156 aprint_error_dev(self, "couldn't establish power handler\n"); 157 158 /* requires HID usage Generic_Desktop:X */ 159 if (!hid_locate(desc, size, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X), 160 uha->reportid, hid_input, &sc->sc_loc_x, &flags)) { 161 aprint_error_dev(sc->sc_dev, 162 "touchscreen has no X report\n"); 163 return; 164 } 165 switch (flags & TSCREEN_FLAGS_MASK) { 166 case 0: 167 sc->flags |= UTS_ABS; 168 break; 169 case HIO_RELATIVE: 170 break; 171 default: 172 aprint_error_dev(sc->sc_dev, 173 "X report 0x%04x not supported\n", flags); 174 return; 175 } 176 177 /* requires HID usage Generic_Desktop:Y */ 178 if (!hid_locate(desc, size, HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y), 179 uha->reportid, hid_input, &sc->sc_loc_y, &flags)) { 180 aprint_error_dev(sc->sc_dev, 181 "touchscreen has no Y report\n"); 182 return; 183 } 184 switch (flags & TSCREEN_FLAGS_MASK) { 185 case 0: 186 sc->flags |= UTS_ABS; 187 break; 188 case HIO_RELATIVE: 189 break; 190 default: 191 aprint_error_dev(sc->sc_dev, 192 "Y report 0x%04x not supported\n", flags); 193 return; 194 } 195 196 /* requires HID usage Digitizer:Tip_Switch */ 197 if (!hid_locate(desc, size, HID_USAGE2(HUP_DIGITIZERS, HUD_TIP_SWITCH), 198 uha->reportid, hid_input, &sc->sc_loc_btn, 0)) { 199 aprint_error_dev(sc->sc_dev, 200 "touchscreen has no tip switch report\n"); 201 return; 202 } 203 204 /* requires HID usage Digitizer:In_Range */ 205 if (!hid_locate(desc, size, HID_USAGE2(HUP_DIGITIZERS, HUD_IN_RANGE), 206 uha->reportid, hid_input, &sc->sc_loc_z, &flags)) { 207 if (uha->uiaa->uiaa_vendor == USB_VENDOR_ELAN) { 208 /* 209 * XXX 210 * ELAN touchscreens error out here but still return 211 * valid data 212 */ 213 aprint_debug_dev(sc->sc_dev, 214 "ELAN touchscreen found, working around bug.\n"); 215 } else { 216 aprint_error_dev(sc->sc_dev, 217 "touchscreen has no range report\n"); 218 return; 219 } 220 } 221 222 /* multi-touch support would need HUD_CONTACTID and HUD_CONTACTMAX */ 223 224 #ifdef UTS_DEBUG 225 DPRINTF(("uts_attach: sc=%p\n", sc)); 226 DPRINTF(("uts_attach: X\t%d/%d\n", 227 sc->sc_loc_x.pos, sc->sc_loc_x.size)); 228 DPRINTF(("uts_attach: Y\t%d/%d\n", 229 sc->sc_loc_y.pos, sc->sc_loc_y.size)); 230 DPRINTF(("uts_attach: Z\t%d/%d\n", 231 sc->sc_loc_z.pos, sc->sc_loc_z.size)); 232 #endif 233 234 a.accessops = &uts_accessops; 235 a.accesscookie = sc; 236 237 sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint, CFARGS_NONE); 238 239 /* calibrate the touchscreen */ 240 memset(&sc->sc_calibcoords, 0, sizeof(sc->sc_calibcoords)); 241 sc->sc_calibcoords.maxx = 4095; 242 sc->sc_calibcoords.maxy = 4095; 243 sc->sc_calibcoords.samplelen = WSMOUSE_CALIBCOORDS_RESET; 244 d = hid_start_parse(desc, size, hid_input); 245 if (d != NULL) { 246 while (hid_get_item(d, &item)) { 247 if (item.kind != hid_input 248 || HID_GET_USAGE_PAGE(item.usage) != HUP_GENERIC_DESKTOP 249 || item.report_ID != uha->reportid) 250 continue; 251 if (HID_GET_USAGE(item.usage) == HUG_X) { 252 sc->sc_calibcoords.minx = item.logical_minimum; 253 sc->sc_calibcoords.maxx = item.logical_maximum; 254 } 255 if (HID_GET_USAGE(item.usage) == HUG_Y) { 256 sc->sc_calibcoords.miny = item.logical_minimum; 257 sc->sc_calibcoords.maxy = item.logical_maximum; 258 } 259 } 260 hid_end_parse(d); 261 } 262 tpcalib_init(&sc->sc_tpcalib); 263 tpcalib_ioctl(&sc->sc_tpcalib, WSMOUSEIO_SCALIBCOORDS, 264 (void *)&sc->sc_calibcoords, 0, 0); 265 266 return; 267 } 268 269 Static int 270 uts_detach(device_t self, int flags) 271 { 272 struct uts_softc *sc = device_private(self); 273 int error; 274 275 __USE(sc); 276 DPRINTF(("uts_detach: sc=%p flags=%d\n", sc, flags)); 277 278 error = config_detach_children(self, flags); 279 if (error) 280 return error; 281 282 pmf_device_deregister(self); 283 return 0; 284 } 285 286 Static void 287 uts_childdet(device_t self, device_t child) 288 { 289 struct uts_softc *sc = device_private(self); 290 291 KASSERT(sc->sc_wsmousedev == child); 292 sc->sc_wsmousedev = NULL; 293 } 294 295 Static int 296 uts_activate(device_t self, enum devact act) 297 { 298 struct uts_softc *sc = device_private(self); 299 300 switch (act) { 301 case DVACT_DEACTIVATE: 302 sc->sc_dying = 1; 303 return 0; 304 default: 305 return EOPNOTSUPP; 306 } 307 } 308 309 Static int 310 uts_enable(void *v) 311 { 312 struct uts_softc *sc = v; 313 int error; 314 315 DPRINTFN(1,("uts_enable: sc=%p\n", sc)); 316 317 if (sc->sc_dying) 318 return EIO; 319 320 if (sc->sc_enabled) 321 return EBUSY; 322 323 error = uhidev_open(sc->sc_hdev, &uts_intr, sc); 324 325 if (error != 0) 326 return error; 327 328 sc->sc_enabled = 1; 329 sc->sc_buttons = 0; 330 331 return 0; 332 } 333 334 Static void 335 uts_disable(void *v) 336 { 337 struct uts_softc *sc = v; 338 339 DPRINTFN(1,("uts_disable: sc=%p\n", sc)); 340 341 if (!sc->sc_enabled) 342 return; 343 344 sc->sc_enabled = 0; 345 uhidev_close(sc->sc_hdev); 346 } 347 348 Static int 349 uts_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l) 350 { 351 struct uts_softc *sc = v; 352 353 switch (cmd) { 354 case WSMOUSEIO_GTYPE: 355 if (sc->flags & UTS_ABS) 356 *(u_int *)data = WSMOUSE_TYPE_TPANEL; 357 else 358 *(u_int *)data = WSMOUSE_TYPE_USB; 359 return 0; 360 case WSMOUSEIO_SCALIBCOORDS: 361 case WSMOUSEIO_GCALIBCOORDS: 362 return tpcalib_ioctl(&sc->sc_tpcalib, cmd, data, flag, l); 363 } 364 365 return EPASSTHROUGH; 366 } 367 368 Static void 369 uts_intr(void *cookie, void *ibuf, u_int len) 370 { 371 struct uts_softc *sc = cookie; 372 int dx, dy, dz; 373 uint32_t buttons = 0; 374 int flags, s; 375 376 DPRINTFN(5,("uts_intr: len=%d\n", len)); 377 378 flags = WSMOUSE_INPUT_DELTA | WSMOUSE_INPUT_ABSOLUTE_Z; 379 380 dx = hid_get_data(ibuf, &sc->sc_loc_x); 381 if (sc->flags & UTS_ABS) { 382 flags |= (WSMOUSE_INPUT_ABSOLUTE_X | WSMOUSE_INPUT_ABSOLUTE_Y); 383 dy = hid_get_data(ibuf, &sc->sc_loc_y); 384 tpcalib_trans(&sc->sc_tpcalib, dx, dy, &dx, &dy); 385 } else 386 dy = -hid_get_data(ibuf, &sc->sc_loc_y); 387 388 dz = hid_get_data(ibuf, &sc->sc_loc_z); 389 390 if (hid_get_data(ibuf, &sc->sc_loc_btn)) 391 buttons |= 1; 392 393 if (dx != 0 || dy != 0 || dz != 0 || buttons != sc->sc_buttons) { 394 DPRINTFN(10,("uts_intr: x:%d y:%d z:%d buttons:%#x\n", 395 dx, dy, dz, buttons)); 396 sc->sc_buttons = buttons; 397 if (sc->sc_wsmousedev != NULL) { 398 s = spltty(); 399 wsmouse_input(sc->sc_wsmousedev, buttons, dx, dy, dz, 0, 400 flags); 401 splx(s); 402 } 403 } 404 } 405
Indexes created Mon Sep 29 21:09:56 GMT 2025