uep.c revision 1.10.8.1
1 /* $NetBSD: uep.c,v 1.10.8.1 2008/05/18 12:34:50 yamt Exp $ */ 2 3 /* 4 * Copyright (c) 2004 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Tyler C. Sarna (tsarna (at) netbsd.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 * eGalax USB touchpanel controller driver. 34 * 35 * For Programming Documentation, see: 36 * 37 * http://www.egalax.com/SoftwareProgrammingGuide_1.1.pdf 38 */ 39 40 #include <sys/cdefs.h> 41 __KERNEL_RCSID(0, "$NetBSD: uep.c,v 1.10.8.1 2008/05/18 12:34:50 yamt Exp $"); 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/kernel.h> 46 #include <sys/malloc.h> 47 #include <sys/device.h> 48 #include <sys/ioctl.h> 49 #include <sys/vnode.h> 50 51 #include <dev/usb/usb.h> 52 #include <dev/usb/usbdi.h> 53 #include <dev/usb/usbdi_util.h> 54 #include <dev/usb/usbdevs.h> 55 #include <dev/usb/usb_quirks.h> 56 57 #include <dev/wscons/wsconsio.h> 58 #include <dev/wscons/wsmousevar.h> 59 #include <dev/wscons/tpcalibvar.h> 60 61 #define UIDSTR "eGalax USB SN000000" 62 63 struct uep_softc { 64 USBBASEDEVICE sc_dev; 65 usbd_device_handle sc_udev; /* device */ 66 usbd_interface_handle sc_iface; /* interface */ 67 int sc_iface_number; 68 69 int sc_intr_number; /* interrupt number */ 70 usbd_pipe_handle sc_intr_pipe; /* interrupt pipe */ 71 u_char *sc_ibuf; 72 int sc_isize; 73 74 device_ptr_t sc_wsmousedev; /* wsmouse device */ 75 struct tpcalib_softc sc_tpcalib; /* calibration */ 76 77 u_char sc_enabled; 78 u_char sc_dying; 79 }; 80 81 static struct wsmouse_calibcoords default_calib = { 82 .minx = 0, 83 .miny = 0, 84 .maxx = 2047, 85 .maxy = 2047, 86 .samplelen = WSMOUSE_CALIBCOORDS_RESET, 87 }; 88 89 Static void uep_intr(usbd_xfer_handle, usbd_private_handle, usbd_status); 90 91 Static int uep_enable(void *); 92 Static void uep_disable(void *); 93 Static int uep_ioctl(void *, u_long, void *, int, struct lwp *); 94 95 const struct wsmouse_accessops uep_accessops = { 96 uep_enable, 97 uep_ioctl, 98 uep_disable, 99 }; 100 101 int uep_match(device_t, struct cfdata *, void *); 102 void uep_attach(device_t, device_t, void *); 103 void uep_childdet(device_t, device_t); 104 int uep_detach(device_t, int); 105 int uep_activate(device_t, enum devact); 106 extern struct cfdriver uep_cd; 107 CFATTACH_DECL2(uep, sizeof(struct uep_softc), uep_match, uep_attach, 108 uep_detach, uep_activate, NULL, uep_childdet); 109 110 USB_MATCH(uep) 111 { 112 USB_MATCH_START(uep, uaa); 113 114 if ((uaa->vendor == USB_VENDOR_EGALAX) && ( 115 (uaa->product == USB_PRODUCT_EGALAX_TPANEL) 116 || (uaa->product == USB_PRODUCT_EGALAX_TPANEL2) 117 )) 118 return UMATCH_VENDOR_PRODUCT; 119 120 if ((uaa->vendor == USB_VENDOR_EGALAX2) 121 && (uaa->product == USB_PRODUCT_EGALAX2_TPANEL)) 122 return UMATCH_VENDOR_PRODUCT; 123 124 125 return UMATCH_NONE; 126 } 127 128 USB_ATTACH(uep) 129 { 130 USB_ATTACH_START(uep, sc, uaa); 131 usbd_device_handle dev = uaa->device; 132 usb_config_descriptor_t *cdesc; 133 usb_interface_descriptor_t *id; 134 usb_endpoint_descriptor_t *ed; 135 struct wsmousedev_attach_args a; 136 char *devinfop; 137 usbd_status err; 138 int i, found; 139 140 devinfop = usbd_devinfo_alloc(dev, 0); 141 USB_ATTACH_SETUP; 142 printf("%s: %s\n", USBDEVNAME(sc->sc_dev), devinfop); 143 usbd_devinfo_free(devinfop); 144 145 sc->sc_udev = dev; 146 sc->sc_intr_number = -1; 147 sc->sc_intr_pipe = NULL; 148 sc->sc_enabled = sc->sc_isize = 0; 149 150 /* Move the device into the configured state. */ 151 err = usbd_set_config_index(dev, 0, 1); 152 if (err) { 153 printf("\n%s: failed to set configuration, err=%s\n", 154 USBDEVNAME(sc->sc_dev), usbd_errstr(err)); 155 sc->sc_dying = 1; 156 USB_ATTACH_ERROR_RETURN; 157 } 158 159 /* get the config descriptor */ 160 cdesc = usbd_get_config_descriptor(sc->sc_udev); 161 if (cdesc == NULL) { 162 printf("%s: failed to get configuration descriptor\n", 163 USBDEVNAME(sc->sc_dev)); 164 sc->sc_dying = 1; 165 USB_ATTACH_ERROR_RETURN; 166 } 167 168 /* get the interface */ 169 err = usbd_device2interface_handle(dev, 0, &sc->sc_iface); 170 if (err) { 171 printf("\n%s: failed to get interface, err=%s\n", 172 USBDEVNAME(sc->sc_dev), usbd_errstr(err)); 173 sc->sc_dying = 1; 174 USB_ATTACH_ERROR_RETURN; 175 } 176 177 /* Find the interrupt endpoint */ 178 id = usbd_get_interface_descriptor(sc->sc_iface); 179 sc->sc_iface_number = id->bInterfaceNumber; 180 found = 0; 181 182 for (i = 0; i < id->bNumEndpoints; i++) { 183 ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i); 184 if (ed == NULL) { 185 printf("%s: no endpoint descriptor for %d\n", 186 USBDEVNAME(sc->sc_dev), i); 187 sc->sc_dying = 1; 188 USB_ATTACH_ERROR_RETURN; 189 } 190 191 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && 192 UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { 193 sc->sc_intr_number = ed->bEndpointAddress; 194 sc->sc_isize = UGETW(ed->wMaxPacketSize); 195 } 196 } 197 198 if (sc->sc_intr_number== -1) { 199 printf("%s: Could not find interrupt in\n", 200 USBDEVNAME(sc->sc_dev)); 201 sc->sc_dying = 1; 202 USB_ATTACH_ERROR_RETURN; 203 } 204 205 usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, 206 USBDEV(sc->sc_dev)); 207 208 a.accessops = &uep_accessops; 209 a.accesscookie = sc; 210 211 sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint); 212 213 tpcalib_init(&sc->sc_tpcalib); 214 tpcalib_ioctl(&sc->sc_tpcalib, WSMOUSEIO_SCALIBCOORDS, 215 (void *)&default_calib, 0, 0); 216 217 USB_ATTACH_SUCCESS_RETURN; 218 } 219 220 USB_DETACH(uep) 221 { 222 USB_DETACH_START(uep, sc); 223 int rv = 0; 224 225 if (sc->sc_intr_pipe != NULL) { 226 usbd_abort_pipe(sc->sc_intr_pipe); 227 usbd_close_pipe(sc->sc_intr_pipe); 228 sc->sc_intr_pipe = NULL; 229 } 230 231 sc->sc_dying = 1; 232 233 /* save current calib as defaults */ 234 default_calib = sc->sc_tpcalib.sc_saved; 235 236 if (sc->sc_wsmousedev != NULL) 237 rv = config_detach(sc->sc_wsmousedev, flags); 238 239 usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, 240 USBDEV(sc->sc_dev)); 241 242 return rv; 243 } 244 245 void 246 uep_childdet(device_t self, device_t child) 247 { 248 struct uep_softc *sc = device_private(self); 249 250 KASSERT(sc->sc_wsmousedev == child); 251 sc->sc_wsmousedev = NULL; 252 } 253 254 int 255 uep_activate(device_t self, enum devact act) 256 { 257 struct uep_softc *sc = device_private(self); 258 int rv = 0; 259 260 switch (act) { 261 case DVACT_ACTIVATE: 262 return EOPNOTSUPP; 263 264 case DVACT_DEACTIVATE: 265 if (sc->sc_wsmousedev != NULL) 266 rv = config_deactivate(sc->sc_wsmousedev); 267 sc->sc_dying = 1; 268 break; 269 } 270 271 return rv; 272 } 273 274 Static int 275 uep_enable(void *v) 276 { 277 struct uep_softc *sc = v; 278 int err; 279 280 if (sc->sc_dying) 281 return EIO; 282 283 if (sc->sc_enabled) 284 return EBUSY; 285 286 if (sc->sc_isize == 0) 287 return 0; 288 sc->sc_ibuf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK); 289 err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_intr_number, 290 USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc, sc->sc_ibuf, 291 sc->sc_isize, uep_intr, USBD_DEFAULT_INTERVAL); 292 if (err) { 293 free(sc->sc_ibuf, M_USBDEV); 294 sc->sc_intr_pipe = NULL; 295 return EIO; 296 } 297 298 sc->sc_enabled = 1; 299 300 return 0; 301 } 302 303 Static void 304 uep_disable(void *v) 305 { 306 struct uep_softc *sc = v; 307 308 if (!sc->sc_enabled) { 309 printf("uep_disable: already disabled!\n"); 310 return; 311 } 312 313 /* Disable interrupts. */ 314 if (sc->sc_intr_pipe != NULL) { 315 usbd_abort_pipe(sc->sc_intr_pipe); 316 usbd_close_pipe(sc->sc_intr_pipe); 317 sc->sc_intr_pipe = NULL; 318 } 319 320 if (sc->sc_ibuf != NULL) { 321 free(sc->sc_ibuf, M_USBDEV); 322 sc->sc_ibuf = NULL; 323 } 324 325 sc->sc_enabled = 0; 326 } 327 328 Static int 329 uep_ioctl(void *v, u_long cmd, void *data, int flag, struct lwp *l) 330 { 331 struct uep_softc *sc = v; 332 struct wsmouse_id *id; 333 334 switch (cmd) { 335 case WSMOUSEIO_GTYPE: 336 *(u_int *)data = WSMOUSE_TYPE_TPANEL; 337 return 0; 338 339 case WSMOUSEIO_GETID: 340 /* 341 * return unique ID string 342 * "<vendor> <model> <serial number>" 343 * unfortunately we have no serial number... 344 */ 345 id = (struct wsmouse_id *)data; 346 if (id->type != WSMOUSE_ID_TYPE_UIDSTR) 347 return EINVAL; 348 349 strcpy(id->data, UIDSTR); 350 id->length = strlen(UIDSTR); 351 return 0; 352 353 case WSMOUSEIO_SCALIBCOORDS: 354 case WSMOUSEIO_GCALIBCOORDS: 355 return tpcalib_ioctl(&sc->sc_tpcalib, cmd, data, flag, l); 356 } 357 358 return EPASSTHROUGH; 359 } 360 361 void 362 uep_intr(usbd_xfer_handle xfer, usbd_private_handle addr, usbd_status status) 363 { 364 struct uep_softc *sc = addr; 365 u_char *p = sc->sc_ibuf; 366 u_int32_t len; 367 int x = 0, y = 0, s; 368 369 usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL); 370 371 if (status == USBD_CANCELLED) 372 return; 373 374 if (status != USBD_NORMAL_COMPLETION) { 375 printf("%s: status %d\n", USBDEVNAME(sc->sc_dev), status); 376 usbd_clear_endpoint_stall_async(sc->sc_intr_pipe); 377 return; 378 } 379 380 if (len != 5) { 381 #if 0 382 printf("%s: bad input length %d != %d\n", 383 USBDEVNAME(sc->sc_dev), len, sc->sc_isize); 384 #endif 385 return; 386 } 387 388 if ((p[0] & 0xFE) != 0x80) { 389 printf("%s: bad input packet format\n", USBDEVNAME(sc->sc_dev)); 390 return; 391 } 392 393 if (sc->sc_wsmousedev != NULL) { 394 /* 395 * Packet format is 5 bytes: 396 * 397 * 1000000T 398 * 0000AAAA 399 * 0AAAAAAA 400 * 0000BBBB 401 * 0BBBBBBB 402 * 403 * T: 1=touched 0=not touched 404 * A: bits of axis A position, MSB to LSB 405 * B: bits of axis B position, MSB to LSB 406 * 407 * For the unit I have, A = Y and B = X. 408 * I don't know if units exist with A=X and B=Y, 409 * if so we'll cross that bridge when we come to it. 410 * 411 * The controller sends a stream of T=1 events while the 412 * panel is touched, followed by a single T=0 event. 413 * 414 */ 415 416 x = (p[3] << 7) | p[4]; 417 y = (p[1] << 7) | p[2]; 418 419 tpcalib_trans(&sc->sc_tpcalib, x, y, &x, &y); 420 421 s = spltty(); 422 wsmouse_input(sc->sc_wsmousedev, p[0] & 0x01, x, y, 0, 0, 423 WSMOUSE_INPUT_ABSOLUTE_X | WSMOUSE_INPUT_ABSOLUTE_Y); 424 splx(s); 425 } 426 } 427
Indexes created Tue Oct 07 21:09:53 GMT 2025