1 /* $OpenBSD: uts.c,v 1.45 2024/05/23 03:21:09 jsg Exp $ */ 2 3 /* 4 * Copyright (c) 2007 Robert Nagy <robert@openbsd.org> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/param.h> 20 #include <sys/systm.h> 21 #include <sys/malloc.h> 22 #include <sys/device.h> 23 24 #include <machine/intr.h> 25 26 #include <dev/usb/usb.h> 27 #include <dev/usb/usbdi.h> 28 #include <dev/usb/usbdevs.h> 29 30 #include <dev/wscons/wsconsio.h> 31 #include <dev/wscons/wsmousevar.h> 32 33 #ifdef UTS_DEBUG 34 #define DPRINTF(x) do { printf x; } while (0) 35 #else 36 #define DPRINTF(x) 37 #endif 38 39 struct tsscale { 40 int minx, maxx; 41 int miny, maxy; 42 int swapxy; 43 int resx, resy; 44 } def_scale = { 45 67, 1931, 102, 1937, 0, 1024, 768 46 }; 47 48 struct uts_softc { 49 struct device sc_dev; 50 struct usbd_device *sc_udev; 51 struct usbd_interface *sc_iface; 52 int sc_product; 53 int sc_vendor; 54 55 int sc_intr_number; 56 struct usbd_pipe *sc_intr_pipe; 57 u_char *sc_ibuf; 58 int sc_isize; 59 u_int8_t sc_pkts; 60 61 struct device *sc_wsmousedev; 62 63 int sc_enabled; 64 int sc_buttons; 65 int sc_oldx; 66 int sc_oldy; 67 int sc_rawmode; 68 69 struct tsscale sc_tsscale; 70 }; 71 72 struct uts_pos { 73 int down; 74 int x; 75 int y; 76 int z; /* touch pressure */ 77 }; 78 79 const struct usb_devno uts_devs[] = { 80 { USB_VENDOR_FTDI, USB_PRODUCT_FTDI_ITM_TOUCH }, 81 { USB_VENDOR_EGALAX, USB_PRODUCT_EGALAX_TPANEL }, 82 { USB_VENDOR_EGALAX, USB_PRODUCT_EGALAX_TPANEL2 }, 83 { USB_VENDOR_GUNZE, USB_PRODUCT_GUNZE_TOUCHPANEL } 84 }; 85 86 void uts_intr(struct usbd_xfer *, void *, usbd_status); 87 void uts_get_pos(void *addr, struct uts_pos *tp); 88 89 int uts_enable(void *); 90 void uts_disable(void *); 91 int uts_ioctl(void *, u_long, caddr_t, int, struct proc *); 92 93 const struct wsmouse_accessops uts_accessops = { 94 uts_enable, 95 uts_ioctl, 96 uts_disable, 97 }; 98 99 int uts_match(struct device *, void *, void *); 100 void uts_attach(struct device *, struct device *, void *); 101 int uts_detach(struct device *, int); 102 int uts_activate(struct device *, int); 103 104 struct cfdriver uts_cd = { 105 NULL, "uts", DV_DULL 106 }; 107 108 const struct cfattach uts_ca = { 109 sizeof(struct uts_softc), 110 uts_match, 111 uts_attach, 112 uts_detach, 113 uts_activate, 114 }; 115 116 int 117 uts_match(struct device *parent, void *match, void *aux) 118 { 119 struct usb_attach_arg *uaa = aux; 120 usb_interface_descriptor_t *id; 121 122 if (uaa->iface == NULL) 123 return (UMATCH_NONE); 124 125 /* Some eGalax touch screens are HID devices. ignore them */ 126 id = usbd_get_interface_descriptor(uaa->iface); 127 if (id != NULL && id->bInterfaceClass == UICLASS_HID) 128 return (UMATCH_NONE); 129 130 return (usb_lookup(uts_devs, uaa->vendor, uaa->product) != NULL) ? 131 UMATCH_VENDOR_PRODUCT : UMATCH_NONE; 132 } 133 134 void 135 uts_attach(struct device *parent, struct device *self, void *aux) 136 { 137 struct uts_softc *sc = (struct uts_softc *)self; 138 struct usb_attach_arg *uaa = aux; 139 usb_config_descriptor_t *cdesc; 140 usb_interface_descriptor_t *id; 141 usb_endpoint_descriptor_t *ed; 142 struct wsmousedev_attach_args a; 143 int i; 144 145 sc->sc_udev = uaa->device; 146 sc->sc_product = uaa->product; 147 sc->sc_vendor = uaa->vendor; 148 sc->sc_intr_number = -1; 149 sc->sc_intr_pipe = NULL; 150 sc->sc_enabled = sc->sc_isize = 0; 151 152 /* Copy the default scale values to each softc */ 153 bcopy(&def_scale, &sc->sc_tsscale, sizeof(sc->sc_tsscale)); 154 155 /* get the config descriptor */ 156 cdesc = usbd_get_config_descriptor(sc->sc_udev); 157 if (cdesc == NULL) { 158 printf("%s: failed to get configuration descriptor\n", 159 sc->sc_dev.dv_xname); 160 usbd_deactivate(sc->sc_udev); 161 return; 162 } 163 164 /* get the interface */ 165 if (usbd_device2interface_handle(uaa->device, 0, &sc->sc_iface) != 0) { 166 printf("%s: failed to get interface\n", 167 sc->sc_dev.dv_xname); 168 usbd_deactivate(sc->sc_udev); 169 return; 170 } 171 172 /* Find the interrupt endpoint */ 173 id = usbd_get_interface_descriptor(sc->sc_iface); 174 175 for (i = 0; i < id->bNumEndpoints; i++) { 176 ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i); 177 if (ed == NULL) { 178 printf("%s: no endpoint descriptor for %d\n", 179 sc->sc_dev.dv_xname, i); 180 usbd_deactivate(sc->sc_udev); 181 return; 182 } 183 184 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 185 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { 186 sc->sc_intr_number = ed->bEndpointAddress; 187 sc->sc_isize = UGETW(ed->wMaxPacketSize); 188 } 189 } 190 191 if (sc->sc_intr_number== -1) { 192 printf("%s: Could not find interrupt in\n", 193 sc->sc_dev.dv_xname); 194 usbd_deactivate(sc->sc_udev); 195 return; 196 } 197 198 a.accessops = &uts_accessops; 199 a.accesscookie = sc; 200 201 sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint); 202 } 203 204 int 205 uts_detach(struct device *self, int flags) 206 { 207 struct uts_softc *sc = (struct uts_softc *)self; 208 int rv = 0; 209 210 if (sc->sc_intr_pipe != NULL) { 211 usbd_close_pipe(sc->sc_intr_pipe); 212 sc->sc_intr_pipe = NULL; 213 } 214 215 if (sc->sc_wsmousedev != NULL) { 216 rv = config_detach(sc->sc_wsmousedev, flags); 217 sc->sc_wsmousedev = NULL; 218 } 219 220 return (rv); 221 } 222 223 int 224 uts_activate(struct device *self, int act) 225 { 226 struct uts_softc *sc = (struct uts_softc *)self; 227 int rv = 0; 228 229 switch (act) { 230 case DVACT_DEACTIVATE: 231 if (sc->sc_wsmousedev != NULL) 232 rv = config_deactivate(sc->sc_wsmousedev); 233 usbd_deactivate(sc->sc_udev); 234 break; 235 } 236 237 return (rv); 238 } 239 240 int 241 uts_enable(void *v) 242 { 243 struct uts_softc *sc = v; 244 int err; 245 246 if (usbd_is_dying(sc->sc_udev)) 247 return (EIO); 248 249 if (sc->sc_enabled) 250 return (EBUSY); 251 252 if (sc->sc_isize == 0) 253 return (0); 254 sc->sc_ibuf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK); 255 err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_intr_number, 256 USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc, sc->sc_ibuf, 257 sc->sc_isize, uts_intr, USBD_DEFAULT_INTERVAL); 258 if (err) { 259 free(sc->sc_ibuf, M_USBDEV, sc->sc_isize); 260 sc->sc_intr_pipe = NULL; 261 return (EIO); 262 } 263 264 sc->sc_enabled = 1; 265 sc->sc_buttons = 0; 266 267 return (0); 268 } 269 270 void 271 uts_disable(void *v) 272 { 273 struct uts_softc *sc = v; 274 275 if (!sc->sc_enabled) { 276 printf("uts_disable: already disabled!\n"); 277 return; 278 } 279 280 /* Disable interrupts. */ 281 if (sc->sc_intr_pipe != NULL) { 282 usbd_close_pipe(sc->sc_intr_pipe); 283 sc->sc_intr_pipe = NULL; 284 } 285 286 if (sc->sc_ibuf != NULL) { 287 free(sc->sc_ibuf, M_USBDEV, sc->sc_isize); 288 sc->sc_ibuf = NULL; 289 } 290 291 sc->sc_enabled = 0; 292 } 293 294 int 295 uts_ioctl(void *v, u_long cmd, caddr_t data, int flag, struct proc *l) 296 { 297 int error = 0; 298 struct uts_softc *sc = v; 299 struct wsmouse_calibcoords *wsmc = (struct wsmouse_calibcoords *)data; 300 301 DPRINTF(("uts_ioctl(%zu, '%c', %zu)\n", 302 IOCPARM_LEN(cmd), (int) IOCGROUP(cmd), cmd & 0xff)); 303 304 switch (cmd) { 305 case WSMOUSEIO_SCALIBCOORDS: 306 if (!(wsmc->minx >= -32768 && wsmc->maxx >= 0 && 307 wsmc->miny >= -32768 && wsmc->maxy >= 0 && 308 wsmc->resx >= 0 && wsmc->resy >= 0 && 309 wsmc->minx < 32768 && wsmc->maxx < 32768 && 310 wsmc->miny < 32768 && wsmc->maxy < 32768 && 311 (wsmc->maxx - wsmc->minx) != 0 && 312 (wsmc->maxy - wsmc->miny) != 0 && 313 wsmc->resx < 32768 && wsmc->resy < 32768 && 314 wsmc->swapxy >= 0 && wsmc->swapxy <= 1 && 315 wsmc->samplelen >= 0 && wsmc->samplelen <= 1)) 316 return (EINVAL); 317 318 sc->sc_tsscale.minx = wsmc->minx; 319 sc->sc_tsscale.maxx = wsmc->maxx; 320 sc->sc_tsscale.miny = wsmc->miny; 321 sc->sc_tsscale.maxy = wsmc->maxy; 322 sc->sc_tsscale.swapxy = wsmc->swapxy; 323 sc->sc_tsscale.resx = wsmc->resx; 324 sc->sc_tsscale.resy = wsmc->resy; 325 sc->sc_rawmode = wsmc->samplelen; 326 break; 327 case WSMOUSEIO_GCALIBCOORDS: 328 wsmc->minx = sc->sc_tsscale.minx; 329 wsmc->maxx = sc->sc_tsscale.maxx; 330 wsmc->miny = sc->sc_tsscale.miny; 331 wsmc->maxy = sc->sc_tsscale.maxy; 332 wsmc->swapxy = sc->sc_tsscale.swapxy; 333 wsmc->resx = sc->sc_tsscale.resx; 334 wsmc->resy = sc->sc_tsscale.resy; 335 wsmc->samplelen = sc->sc_rawmode; 336 break; 337 case WSMOUSEIO_GTYPE: 338 *(u_int *)data = WSMOUSE_TYPE_TPANEL; 339 break; 340 default: 341 error = ENOTTY; 342 break; 343 } 344 345 return (error); 346 } 347 348 void 349 uts_get_pos(void *addr, struct uts_pos *tp) 350 { 351 struct uts_softc *sc = addr; 352 u_char *p = sc->sc_ibuf; 353 int down, x, y, z; 354 355 switch (sc->sc_product) { 356 case USB_PRODUCT_FTDI_ITM_TOUCH: 357 down = (~p[7] & 0x20); 358 x = ((p[0] & 0x1f) << 7) | (p[3] & 0x7f); 359 /* Invert the Y coordinate */ 360 y = 0x0fff - abs(((p[1] & 0x1f) << 7) | (p[4] & 0x7f)); 361 z = ((p[2] & 0x1) << 7) | (p[5] & 0x7f); 362 sc->sc_pkts = 0x8; 363 break; 364 case USB_PRODUCT_EGALAX_TPANEL: 365 case USB_PRODUCT_EGALAX_TPANEL2: 366 /* 367 * eGalax and Gunze USB touch panels have the same device ID, 368 * so decide upon the vendor ID. 369 */ 370 switch (sc->sc_vendor) { 371 case USB_VENDOR_EGALAX: 372 down = (p[0] & 0x01); 373 /* Invert the X coordinate */ 374 x = 0x07ff - abs(((p[3] & 0x0f) << 7) | (p[4] & 0x7f)); 375 y = ((p[1] & 0x0f) << 7) | (p[2] & 0x7f); 376 z = down; 377 sc->sc_pkts = 0x5; 378 break; 379 case USB_VENDOR_GUNZE: 380 down = (~p[7] & 0x20); 381 /* Invert the X coordinate */ 382 x = 0x0fff - abs(((p[0] & 0x1f) << 7) | (p[2] & 0x7f)); 383 y = ((p[1] & 0x1f) << 7) | (p[3] & 0x7f); 384 z = (down != 0); 385 sc->sc_pkts = 0x4; 386 break; 387 } 388 break; 389 } 390 391 DPRINTF(("%s: down = 0x%x, sc->sc_pkts = 0x%x\n", 392 sc->sc_dev.dv_xname, down, sc->sc_pkts)); 393 394 /* x/y values are not reliable if there is no pressure */ 395 if (down) { 396 if (sc->sc_tsscale.swapxy && !sc->sc_rawmode) { 397 /* Swap X/Y-Axis */ 398 tp->y = x; 399 tp->x = y; 400 } else { 401 tp->x = x; 402 tp->y = y; 403 } 404 if (!sc->sc_rawmode && 405 (sc->sc_tsscale.maxx - sc->sc_tsscale.minx) != 0 && 406 (sc->sc_tsscale.maxy - sc->sc_tsscale.miny) != 0) { 407 /* Scale down to the screen resolution. */ 408 tp->x = ((tp->x - sc->sc_tsscale.minx) * 409 sc->sc_tsscale.resx) / 410 (sc->sc_tsscale.maxx - sc->sc_tsscale.minx); 411 tp->y = ((tp->y - sc->sc_tsscale.miny) * 412 sc->sc_tsscale.resy) / 413 (sc->sc_tsscale.maxy - sc->sc_tsscale.miny); 414 } 415 } else { 416 tp->x = sc->sc_oldx; 417 tp->y = sc->sc_oldy; 418 } 419 tp->z = z; 420 tp->down = down; 421 } 422 423 void 424 uts_intr(struct usbd_xfer *xfer, void *addr, usbd_status status) 425 { 426 struct uts_softc *sc = addr; 427 u_int32_t len; 428 int s; 429 struct uts_pos tp; 430 431 if (status == USBD_CANCELLED) 432 return; 433 434 if (status != USBD_NORMAL_COMPLETION) { 435 printf("%s: status %d\n", sc->sc_dev.dv_xname, status); 436 if (status == USBD_STALLED) 437 usbd_clear_endpoint_stall_async(sc->sc_intr_pipe); 438 return; 439 } 440 441 usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL); 442 443 s = spltty(); 444 445 uts_get_pos(sc, &tp); 446 447 if (len != sc->sc_pkts) { 448 DPRINTF(("%s: bad input length %d != %d\n", 449 sc->sc_dev.dv_xname, len, sc->sc_isize)); 450 splx(s); 451 return; 452 } 453 454 DPRINTF(("%s: tp.down = %d, tp.z = %d, tp.x = %d, tp.y = %d\n", 455 sc->sc_dev.dv_xname, tp.down, tp.z, tp.x, tp.y)); 456 457 WSMOUSE_TOUCH(sc->sc_wsmousedev, tp.down, tp.x, tp.y, tp.z, 0); 458 sc->sc_oldy = tp.y; 459 sc->sc_oldx = tp.x; 460 461 splx(s); 462 } 463