usb4bsd: Port input devices (uep, uhid, ukbd, ums) and hook into build.
[dragonfly.git] / sys / bus / u4b / input / uep.c
CommitLineData
12bd3c8b
SW
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
8d7664cb
SW
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>
12bd3c8b
SW
49
50#include <sys/ioccom.h>
51#include <sys/fcntl.h>
52#include <sys/tty.h>
53
54#define USB_DEBUG_VAR uep_debug
8d7664cb 55#include <bus/u4b/usb_debug.h>
12bd3c8b
SW
56
57#ifdef USB_DEBUG
58static int uep_debug = 0;
59
60static SYSCTL_NODE(_hw_usb, OID_AUTO, uep, CTLFLAG_RW, 0, "USB uep");
61SYSCTL_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
82enum {
83 UEP_INTR_DT,
84 UEP_N_TRANSFER,
85};
86
87struct uep_softc {
8d7664cb 88 struct lock lock;
12bd3c8b
SW
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
102static usb_callback_t uep_intr_callback;
103
104static device_probe_t uep_probe;
105static device_attach_t uep_attach;
106static device_detach_t uep_detach;
107
108static usb_fifo_cmd_t uep_start_read;
109static usb_fifo_cmd_t uep_stop_read;
110static usb_fifo_open_t uep_open;
111static usb_fifo_close_t uep_close;
112
113static void uep_put_queue(struct uep_softc *, u_char *);
114
115static 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
123static int
124get_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
151static void
152uep_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
190static void
191uep_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
280static 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
291static 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
297static int
298uep_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
312static int
313uep_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
8d7664cb 321 lockinit(&sc->lock, "uep lock", 0, 0);
12bd3c8b
SW
322
323 error = usbd_transfer_setup(uaa->device, &uaa->info.bIfaceIndex,
8d7664cb 324 sc->xfer, uep_config, UEP_N_TRANSFER, sc, &sc->lock);
12bd3c8b
SW
325
326 if (error) {
327 DPRINTF("usbd_transfer_setup error=%s\n", usbd_errstr(error));
328 goto detach;
329 }
330
8d7664cb 331 error = usb_fifo_attach(uaa->device, sc, &sc->lock, &uep_fifo_methods,
12bd3c8b
SW
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
344detach:
345 uep_detach(dev);
346
347 return (ENOMEM); /* XXX */
348}
349
350static int
351uep_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
8d7664cb 359 lockuninit(&sc->lock);
12bd3c8b
SW
360
361 return (0);
362}
363
364static void
365uep_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
382static void
383uep_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
390static void
391uep_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
397static int
398uep_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
415static void
416uep_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
426static devclass_t uep_devclass;
427
428static device_method_t uep_methods[] = {
429 DEVMETHOD(device_probe, uep_probe),
430 DEVMETHOD(device_attach, uep_attach),
431 DEVMETHOD(device_detach, uep_detach),
432 { 0, 0 },
433};
434
435static driver_t uep_driver = {
436 .name = "uep",
437 .methods = uep_methods,
438 .size = sizeof(struct uep_softc),
439};
440
441DRIVER_MODULE(uep, uhub, uep_driver, uep_devclass, NULL, NULL);
442MODULE_DEPEND(uep, usb, 1, 1, 1);
443MODULE_VERSION(uep, 1);