1 /*- 2 * Copyright 2010, Gleb Smirnoff <glebius@FreeBSD.org> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * $FreeBSD$ 27 */ 28 29 /* 30 * http://home.eeti.com.tw/web20/drivers/Software%20Programming%20Guide_v2.0.pdf 31 */ 32 33 #include <sys/param.h> 34 #include <sys/bus.h> 35 #include <sys/callout.h> 36 #include <sys/conf.h> 37 #include <sys/kernel.h> 38 #include <sys/lock.h> 39 #include <sys/module.h> 40 #include <sys/mutex.h> 41 #include <sys/sysctl.h> 42 #include <sys/systm.h> 43 44 #include <bus/u4b/usb.h> 45 #include <bus/u4b/usbdi.h> 46 #include <bus/u4b/usbdi_util.h> 47 #include <bus/u4b/usbhid.h> 48 #include <bus/u4b/usbdevs.h> 49 50 #include <sys/ioccom.h> 51 #include <sys/fcntl.h> 52 #include <sys/tty.h> 53 54 #define USB_DEBUG_VAR uep_debug 55 #include <bus/u4b/usb_debug.h> 56 57 #ifdef USB_DEBUG 58 static int uep_debug = 0; 59 60 static SYSCTL_NODE(_hw_usb, OID_AUTO, uep, CTLFLAG_RW, 0, "USB uep"); 61 SYSCTL_INT(_hw_usb_uep, OID_AUTO, debug, CTLFLAG_RW, 62 &uep_debug, 0, "Debug level"); 63 #endif 64 65 #define UEP_MAX_X 2047 66 #define UEP_MAX_Y 2047 67 68 #define UEP_DOWN 0x01 69 #define UEP_PACKET_LEN_MAX 16 70 #define UEP_PACKET_LEN_REPORT 5 71 #define UEP_PACKET_LEN_REPORT2 6 72 #define UEP_PACKET_DIAG 0x0a 73 #define UEP_PACKET_REPORT_MASK 0xe0 74 #define UEP_PACKET_REPORT 0x80 75 #define UEP_PACKET_REPORT_PRESSURE 0xc0 76 #define UEP_PACKET_REPORT_PLAYER 0xa0 77 #define UEP_PACKET_LEN_MASK 78 79 #define UEP_FIFO_BUF_SIZE 8 /* bytes */ 80 #define UEP_FIFO_QUEUE_MAXLEN 50 /* units */ 81 82 enum { 83 UEP_INTR_DT, 84 UEP_N_TRANSFER, 85 }; 86 87 struct uep_softc { 88 struct lock lock; 89 90 struct usb_xfer *xfer[UEP_N_TRANSFER]; 91 struct usb_fifo_sc fifo; 92 93 u_int pollrate; 94 u_int state; 95 #define UEP_ENABLED 0x01 96 97 /* Reassembling buffer. */ 98 u_char buf[UEP_PACKET_LEN_MAX]; 99 uint8_t buf_len; 100 }; 101 102 static usb_callback_t uep_intr_callback; 103 104 static device_probe_t uep_probe; 105 static device_attach_t uep_attach; 106 static device_detach_t uep_detach; 107 108 static usb_fifo_cmd_t uep_start_read; 109 static usb_fifo_cmd_t uep_stop_read; 110 static usb_fifo_open_t uep_open; 111 static usb_fifo_close_t uep_close; 112 113 static void uep_put_queue(struct uep_softc *, u_char *); 114 115 static struct usb_fifo_methods uep_fifo_methods = { 116 .f_open = &uep_open, 117 .f_close = &uep_close, 118 .f_start_read = &uep_start_read, 119 .f_stop_read = &uep_stop_read, 120 .basename[0] = "uep", 121 }; 122 123 static int 124 get_pkt_len(u_char *buf) 125 { 126 if (buf[0] == UEP_PACKET_DIAG) { 127 int len; 128 129 len = buf[1] + 2; 130 if (len > UEP_PACKET_LEN_MAX) { 131 DPRINTF("bad packet len %u\n", len); 132 return (UEP_PACKET_LEN_MAX); 133 } 134 135 return (len); 136 } 137 138 switch (buf[0] & UEP_PACKET_REPORT_MASK) { 139 case UEP_PACKET_REPORT: 140 return (UEP_PACKET_LEN_REPORT); 141 case UEP_PACKET_REPORT_PRESSURE: 142 case UEP_PACKET_REPORT_PLAYER: 143 case UEP_PACKET_REPORT_PRESSURE | UEP_PACKET_REPORT_PLAYER: 144 return (UEP_PACKET_LEN_REPORT2); 145 default: 146 DPRINTF("bad packet len 0\n"); 147 return (0); 148 } 149 } 150 151 static void 152 uep_process_pkt(struct uep_softc *sc, u_char *buf) 153 { 154 int32_t x, y; 155 156 if ((buf[0] & 0xFE) != 0x80) { 157 DPRINTF("bad input packet format 0x%.2x\n", buf[0]); 158 return; 159 } 160 161 /* 162 * Packet format is 5 bytes: 163 * 164 * 1000000T 165 * 0000AAAA 166 * 0AAAAAAA 167 * 0000BBBB 168 * 0BBBBBBB 169 * 170 * T: 1=touched 0=not touched 171 * A: bits of axis A position, MSB to LSB 172 * B: bits of axis B position, MSB to LSB 173 * 174 * For the unit I have, which is CTF1020-S from CarTFT.com, 175 * A = X and B = Y. But in NetBSD uep(4) it is other way round :) 176 * 177 * The controller sends a stream of T=1 events while the 178 * panel is touched, followed by a single T=0 event. 179 * 180 */ 181 182 x = (buf[1] << 7) | buf[2]; 183 y = (buf[3] << 7) | buf[4]; 184 185 DPRINTFN(2, "x %u y %u\n", x, y); 186 187 uep_put_queue(sc, buf); 188 } 189 190 static void 191 uep_intr_callback(struct usb_xfer *xfer, usb_error_t error) 192 { 193 struct uep_softc *sc = usbd_xfer_softc(xfer); 194 int len; 195 196 usbd_xfer_status(xfer, &len, NULL, NULL, NULL); 197 198 switch (USB_GET_STATE(xfer)) { 199 case USB_ST_TRANSFERRED: 200 { 201 struct usb_page_cache *pc; 202 u_char buf[17], *p; 203 int pkt_len; 204 205 if (len > sizeof(buf)) { 206 DPRINTF("bad input length %d\n", len); 207 goto tr_setup; 208 } 209 210 pc = usbd_xfer_get_frame(xfer, 0); 211 usbd_copy_out(pc, 0, buf, len); 212 213 /* 214 * The below code mimics Linux a lot. I don't know 215 * why NetBSD reads complete packets, but we need 216 * to reassamble 'em like Linux does (tries?). 217 */ 218 if (sc->buf_len > 0) { 219 int res; 220 221 if (sc->buf_len == 1) 222 sc->buf[1] = buf[0]; 223 224 if ((pkt_len = get_pkt_len(sc->buf)) == 0) 225 goto tr_setup; 226 227 res = pkt_len - sc->buf_len; 228 memcpy(sc->buf + sc->buf_len, buf, res); 229 uep_process_pkt(sc, sc->buf); 230 sc->buf_len = 0; 231 232 p = buf + res; 233 len -= res; 234 } else 235 p = buf; 236 237 if (len == 1) { 238 sc->buf[0] = buf[0]; 239 sc->buf_len = 1; 240 241 goto tr_setup; 242 } 243 244 while (len > 0) { 245 if ((pkt_len = get_pkt_len(p)) == 0) 246 goto tr_setup; 247 248 /* full packet: process */ 249 if (pkt_len <= len) { 250 uep_process_pkt(sc, p); 251 } else { 252 /* incomplete packet: save in buffer */ 253 memcpy(sc->buf, p, len); 254 sc->buf_len = len; 255 } 256 p += pkt_len; 257 len -= pkt_len; 258 } 259 } 260 case USB_ST_SETUP: 261 tr_setup: 262 /* check if we can put more data into the FIFO */ 263 if (usb_fifo_put_bytes_max(sc->fifo.fp[USB_FIFO_RX]) != 0) { 264 usbd_xfer_set_frame_len(xfer, 0, 265 usbd_xfer_max_len(xfer)); 266 usbd_transfer_submit(xfer); 267 } 268 break; 269 270 default: 271 if (error != USB_ERR_CANCELLED) { 272 /* try clear stall first */ 273 usbd_xfer_set_stall(xfer); 274 goto tr_setup; 275 } 276 break; 277 } 278 } 279 280 static const struct usb_config uep_config[UEP_N_TRANSFER] = { 281 [UEP_INTR_DT] = { 282 .type = UE_INTERRUPT, 283 .endpoint = UE_ADDR_ANY, 284 .direction = UE_DIR_IN, 285 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,}, 286 .bufsize = 0, /* use wMaxPacketSize */ 287 .callback = &uep_intr_callback, 288 }, 289 }; 290 291 static const STRUCT_USB_HOST_ID uep_devs[] = { 292 {USB_VPI(USB_VENDOR_EGALAX, USB_PRODUCT_EGALAX_TPANEL, 0)}, 293 {USB_VPI(USB_VENDOR_EGALAX, USB_PRODUCT_EGALAX_TPANEL2, 0)}, 294 {USB_VPI(USB_VENDOR_EGALAX2, USB_PRODUCT_EGALAX2_TPANEL, 0)}, 295 }; 296 297 static int 298 uep_probe(device_t dev) 299 { 300 struct usb_attach_arg *uaa = device_get_ivars(dev); 301 302 if (uaa->usb_mode != USB_MODE_HOST) 303 return (ENXIO); 304 if (uaa->info.bConfigIndex != 0) 305 return (ENXIO); 306 if (uaa->info.bIfaceIndex != 0) 307 return (ENXIO); 308 309 return (usbd_lookup_id_by_uaa(uep_devs, sizeof(uep_devs), uaa)); 310 } 311 312 static int 313 uep_attach(device_t dev) 314 { 315 struct usb_attach_arg *uaa = device_get_ivars(dev); 316 struct uep_softc *sc = device_get_softc(dev); 317 int error; 318 319 device_set_usb_desc(dev); 320 321 lockinit(&sc->lock, "uep lock", 0, 0); 322 323 error = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex, 324 sc->xfer, uep_config, UEP_N_TRANSFER, sc, &sc->lock); 325 326 if (error) { 327 DPRINTF("usbd_transfer_setup error=%s\n", usbd_errstr(error)); 328 goto detach; 329 } 330 331 error = usb_fifo_attach(uaa->device, sc, &sc->lock, &uep_fifo_methods, 332 &sc->fifo, device_get_unit(dev), 0 - 1, uaa->info.bIfaceIndex, 333 UID_ROOT, GID_OPERATOR, 0644); 334 335 if (error) { 336 DPRINTF("usb_fifo_attach error=%s\n", usbd_errstr(error)); 337 goto detach; 338 } 339 340 sc->buf_len = 0; 341 342 return (0); 343 344 detach: 345 uep_detach(dev); 346 347 return (ENOMEM); /* XXX */ 348 } 349 350 static int 351 uep_detach(device_t dev) 352 { 353 struct uep_softc *sc = device_get_softc(dev); 354 355 usb_fifo_detach(&sc->fifo); 356 357 usbd_transfer_unsetup(sc->xfer, UEP_N_TRANSFER); 358 359 lockuninit(&sc->lock); 360 361 return (0); 362 } 363 364 static void 365 uep_start_read(struct usb_fifo *fifo) 366 { 367 struct uep_softc *sc = usb_fifo_softc(fifo); 368 u_int rate; 369 370 if ((rate = sc->pollrate) > 1000) 371 rate = 1000; 372 373 if (rate > 0 && sc->xfer[UEP_INTR_DT] != NULL) { 374 usbd_transfer_stop(sc->xfer[UEP_INTR_DT]); 375 usbd_xfer_set_interval(sc->xfer[UEP_INTR_DT], 1000 / rate); 376 sc->pollrate = 0; 377 } 378 379 usbd_transfer_start(sc->xfer[UEP_INTR_DT]); 380 } 381 382 static void 383 uep_stop_read(struct usb_fifo *fifo) 384 { 385 struct uep_softc *sc = usb_fifo_softc(fifo); 386 387 usbd_transfer_stop(sc->xfer[UEP_INTR_DT]); 388 } 389 390 static void 391 uep_put_queue(struct uep_softc *sc, u_char *buf) 392 { 393 usb_fifo_put_data_linear(sc->fifo.fp[USB_FIFO_RX], buf, 394 UEP_PACKET_LEN_REPORT, 1); 395 } 396 397 static int 398 uep_open(struct usb_fifo *fifo, int fflags) 399 { 400 if (fflags & FREAD) { 401 struct uep_softc *sc = usb_fifo_softc(fifo); 402 403 if (sc->state & UEP_ENABLED) 404 return (EBUSY); 405 if (usb_fifo_alloc_buffer(fifo, UEP_FIFO_BUF_SIZE, 406 UEP_FIFO_QUEUE_MAXLEN)) 407 return (ENOMEM); 408 409 sc->state |= UEP_ENABLED; 410 } 411 412 return (0); 413 } 414 415 static void 416 uep_close(struct usb_fifo *fifo, int fflags) 417 { 418 if (fflags & FREAD) { 419 struct uep_softc *sc = usb_fifo_softc(fifo); 420 421 sc->state &= ~(UEP_ENABLED); 422 usb_fifo_free_buffer(fifo); 423 } 424 } 425 426 static devclass_t uep_devclass; 427 428 static device_method_t uep_methods[] = { 429 DEVMETHOD(device_probe, uep_probe), 430 DEVMETHOD(device_attach, uep_attach), 431 DEVMETHOD(device_detach, uep_detach), 432 DEVMETHOD_END 433 }; 434 435 static driver_t uep_driver = { 436 .name = "uep", 437 .methods = uep_methods, 438 .size = sizeof(struct uep_softc), 439 }; 440 441 DRIVER_MODULE(uep, uhub, uep_driver, uep_devclass, NULL, NULL); 442 MODULE_DEPEND(uep, usb, 1, 1, 1); 443 MODULE_VERSION(uep, 1); 444