Date: Tue, 09 Oct 2007 17:47:50 +0100 From: Bartosz Fabianowski <freebsd@chillt.de> To: freebsd-usb@freebsd.org Subject: Introducing support for Wacom Cintiq USB tablet Message-ID: <470BB0B6.5000102@chillt.de>
next in thread | raw e-mail | index | archive | help
[-- Attachment #1 --] Hi list I got a Wacom Cintiq tablet last week and wrote a driver to make it usable under FreeBSD. On the hardware side, the driver communicates with the tablet via the FreeBSD USB stack. On the user side, it implements a subset of the Linux input framework just large enough to make the Linux Wacom X driver happy. The driver is thus compatible with the X driver from the Linux Wacom project [1]. The latter driver compiles and works on FreeBSD once two missing include files are copied over from Linux. To allow the tablet to be accessed by multiple processes concurrently, the driver implements device cloning. As the tablet is detected, it shows up as /dev/uwacom0. This is just a placeholder device and cannot be opened. To read data from the tablet, open /dev/event0 - that device node is invisible, as that is how device cloning works. Caveats: * Only the Cintiq is supported at this time. It would be trivial to extend the driver to other Wacom models, but I don't want to publish code I cannot test. * This is my first device driver, so expect there to be bugs. Feedback from people more knowledgeable is most welcome. I am especially uncertain about proper locking, 64 bit support and device cloning. * The driver works well when X is launched via startx. When using a display manager such as kdm, the monitors for some reason are reset on X startup, leading to the Cintiq briefly detaching so that X does not detect it. The workaround I use is to log in via kdm, log out (at which point X restarts without reseting the monitors) and then log in again. * The Linux Wacom X driver currently does not build or work with X.org 7.3. You will need to portdowngrade your x11-servers/xorg-server to version 1.2.0_2,1. * From the Linux Wacom package, wacdump, the X driver, xidump and xsetwacom work out of the box. wacomcpl-exec is a TCL/Tk script that hardcodes some paths which need to be patched before it will run on FreeBSD. I have attached my driver and instructions for compiling the Linux Wacom X driver. In case the binary attachment gets scrubbed by mailman, I have also uploaded a copy at [2]. I hope others find this driver useful. I certainly am glad I can stick with FreeBSD while enjoying the pressure and tilt sensitivity of a Wacom tablet :). Finally, as writing this driver was done as part of my PhD: This work is financed by the "Irish Research Council for Science, Engineering and Technology: funded by the National Development Plan" - Bartosz [1] http://linuxwacom.sourceforge.net/ [2] http://www.chillt.de/bsdwacom.tbz [-- Attachment #2 --] bsdwacom/ 000755 001751 000000 00000000000 10702726573 012765 5 ustar 00undo wheel 000000 000000 bsdwacom/linuxwacom/ 000755 001751 000000 00000000000 10702727664 015155 5 ustar 00undo wheel 000000 000000 bsdwacom/uwacom/ 000755 001751 000000 00000000000 10702727705 014256 5 ustar 00undo wheel 000000 000000 bsdwacom/README 000644 001751 000000 00000006030 10702727245 013641 0 ustar 00undo wheel 000000 000000 09/10/2007 This is a FreeBSD driver for the Wacom Cintiq tablet. Report any problems (and success stories :) to <freebsd@chillt.de>. This work is financed by the "Irish Research Council for Science, Engineering and Technology: funded by the National Development Plan" You can find the most current version at: http://www.chillt.de/bsdwacom.tbz On the hardware side, the driver communicates with the tablet via the FreeBSD USB stack. On the user side, it implements a subset of the Linux input framework just large enough to make the Linux Wacom X driver happy. The driver is thus compatible with the X driver from the Linux Wacom project [1]. To allow the tablet to be accessed by multiple processes concurrently, the driver implements device cloning. As the tablet is detected, it shows up as /dev/uwacom0. This is just a placeholder device and cannot be opened. To read data from the tablet, open /dev/event0 - that device node is invisible, as that is how device cloning works. Caveats: * Only the Cintiq is supported at this time. It would be trivial to extend the driver to other Wacom models, but I don't want to publish code I cannot test. * This is my first device driver, so expect there to be bugs. Feedback from people more knowledgeable is most welcome. I am especially uncertain about proper locking, 64 bit support and device cloning. * The driver works well when X is launched via startx. When using a display manager such as kdm, the monitors for some reason are reset on X startup, leading to the Cintiq briefly detaching so that X does not detect it. The workaround I use is to log in via kdm, log out (at which point X restarts without reseting the monitors) and then log in again. * The Linux Wacom X driver currently does not build or work with X.org 7.3. You will need to portdowngrade your x11-servers/xorg-server to version 1.2.0_2,1. * From the Linux Wacom package, wacdump, the X driver, xidump and xsetwacom work out of the box. wacomcpl-exec is a TCL/Tk script that hardocdes some paths which need to be patched before it will run on FreeBSD. Instructions (BSD kernel driver): 1. run: tar xf bsdwacom.tbz cd bsdwacom/uwacom make 2. as root run: cp uwacom.ko /boot/kernel echo 'uwacom_load="YES" >> /boot/loader.conf' kldload uwacom 3. (re-)attach tablet 4. as root run: hexdump /dev/event0 5. as you move the stylus on the tablet, data should be streaming in Instructions (X driver): 1. run: cd bsdwacom/linuxwacom fetch "http://ovh.dl.sourceforge.net/sourceforge/linuxwacom/linuxwacom-0.7.8-3.tar.bz2" ./run_configure cd linuxwacom-0.7.8-3 gmake 2. as root run: cp src/xdrv/wacom_drv.so /usr/local/lib/xorg/modules/input 3. set up your xorg.conf as per [2], substituting /dev/event0 for the device name 4. restart X, keeping in mind the third point under caveats above I hope others find this driver useful. I certainly am glad I can stick with FreeBSD while enjoying the pressure and tilt sensitivity of a Wacom tablet :). - Bartosz [1] http://linuxwacom.sourceforge.net/ [2] w.chillt.de/bsdwacom.tbz http://linuxwacom.sourceforge.net/index.php/howto/x11 bsdwacom/uwacom/uwacom.c 000644 001751 000000 00000067553 10702725640 015731 0 ustar 00undo wheel 000000 000000 /*- * Copyright (c) 2007 Bartosz Fabianowski <freebsd@chillt.de> * All rights reserved. * * Financed by the "Irish Research Council for Science, Engineering and * Technology: funded by the National Development Plan" * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions, and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ /*- * Copyright (c) 1998 The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation * by Lennart Augustsson (lennart@augustsson.net) at * Carlstedt Research & Technology. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the NetBSD * Foundation, Inc. and its contributors. * 4. Neither the name of The NetBSD Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ #include <sys/param.h> #include <sys/systm.h> #include <sys/kernel.h> #include <sys/module.h> #include <sys/bus.h> #include <sys/conf.h> #include <sys/tty.h> #include <sys/malloc.h> #include <sys/signalvar.h> #include <sys/endian.h> #include <sys/proc.h> #include <sys/fcntl.h> #include <sys/uio.h> #include <sys/filio.h> #include <sys/poll.h> #include <dev/usb/usb.h> #include <dev/usb/usbdi.h> #include <dev/usb/usbdi_util.h> #define USB_VENDOR_WACOM 0x056a #define USB_PRODUCT_WACOM_CINTIQ_21UX 0x003f #define USB_PACKET_SIZE 10 #define MINOR(t, h) (unit2minor(((t) << 16) | (h))) #define TABLET(x) ((dev2unit(x) >> 16) & 0xff) #define HANDLER(x) (dev2unit(x) & 0xffff) #define HANDLER_MAX 0x10000 #define PACKET_BIT(b, s) ((packet[b] >> (s)) & 1) #define PACKET_BITS(b, s, n) ((((s) + (n) > 32 ? ((packet[(b) - 4]) << (32 - (s))) : 0) | \ ((s) + (n) > 24 ? ((packet[(b) - 3]) << (24 - (s))) : 0) | \ ((s) + (n) > 16 ? ((packet[(b) - 2]) << (16 - (s))) : 0) | \ ((s) + (n) > 8 ? ((packet[(b) - 1]) << ( 8 - (s))) : 0) | \ ((packet[(b) ]) >> (s))) & \ ((n) == 32 ? 0xffffffff : (1 << (n)) - 1)) #define EUWACOMGETVERSION 0x01 #define EUWACOMGETID 0x02 #define EUWACOMGETBM 0x20 #define EUWACOMGETABS 0x40 struct id { uint16_t bus; #define ID_BUS_USB 3 uint16_t vendor; uint16_t product; uint16_t version; }; #define EVT_SYN 0x0000 #define EVT_BTN 0x0001 #define EVT_REL 0x0002 #define EVT_ABS 0x0003 #define EVT_MSC 0x0004 #define EVT_USED 0x0005 #define EVT_MAX 0x001f #define SYN_REPORT 0x0000 #define BTN_MISC_0 0x0100 #define BTN_MISC_1 0x0101 #define BTN_MISC_2 0x0102 #define BTN_MISC_3 0x0103 #define BTN_MISC_4 0x0104 #define BTN_MISC_5 0x0105 #define BTN_MISC_6 0x0106 #define BTN_MISC_7 0x0107 #define BTN_LEFT 0x0110 #define BTN_RIGHT 0x0111 #define BTN_MIDDLE 0x0112 #define BTN_SIDE 0x0113 #define BTN_EXTRA 0x0114 #define BTN_TOOL_PEN 0x0140 #define BTN_TOOL_ERASER 0x0141 #define BTN_TOOL_FINGER 0x0145 #define BTN_TOOL_MOUSE 0x0146 #define BTN_TOUCH 0x014a #define BTN_STYLUS_1 0x014b #define BTN_STYLUS_2 0x014c #define BTN_USED 0x014d #define BTN_MAX 0x01ff #define REL_WHEEL 0x0008 #define REL_MAX 0x000f #define ABS_X 0x0000 #define ABS_Y 0x0001 #define ABS_RX 0x0003 #define ABS_RY 0x0004 #define ABS_PRESSURE 0x0018 #define ABS_DISTANCE 0x0019 #define ABS_TILT_X 0x001a #define ABS_TILT_Y 0x001b #define ABS_MISC 0x0028 #define ABS_USED 0x0029 #define ABS_MAX 0x003f #define MSC_SERIAL 0x0000 #define MSC_MAX 0x0007 #define BM_SIZE(x) (((x) / (sizeof(long) * 8) + 1) * sizeof(long)) #define BM_SET_BIT(x, y) ((x)[(y) / (sizeof(long) * 8)] |= (1 << ((y) % (sizeof(long) * 8)))) static const size_t bm_size[EVT_USED] = { BM_SIZE(EVT_MAX), BM_SIZE(BTN_MAX), BM_SIZE(REL_MAX), BM_SIZE(ABS_MAX), BM_SIZE(MSC_MAX), }; struct abs_axis { int32_t value; int32_t min; int32_t max; int32_t fuzz; int32_t flat; }; struct event { struct timeval time; uint16_t type; uint16_t index; int32_t value; }; #define TOOL_ID_FINGER 0x000f #define SERIAL_FINGER 0xffffffff d_open_t uwacomopen; d_close_t uwacomclose; d_read_t uwacomread; d_ioctl_t uwacomioctl; d_poll_t uwacompoll; d_purge_t uwacompurge; static struct cdevsw uwacomphy_cdevsw = { .d_version = D_VERSION, .d_flags = D_NEEDGIANT, .d_name = "uwacomphy", }; static struct cdevsw uwacom_cdevsw = { .d_version = D_VERSION, .d_flags = D_NEEDGIANT, .d_open = uwacomopen, .d_close = uwacomclose, .d_read = uwacomread, .d_ioctl = uwacomioctl, .d_poll = uwacompoll, .d_purge = uwacompurge, .d_name = "uwacom", }; struct uwacom_handler { LIST_ENTRY(uwacom_handler) link; struct clist queue; struct sigio *queue_sigio; struct selinfo rsel; u_char sleeping; u_char async; }; struct uwacom_softc { USBBASEDEVICE sc_dev; struct cdev *dev; usbd_interface_handle sc_iface; int sc_ep_addr; usbd_pipe_handle sc_intrpipe; u_char sc_buf[USB_PACKET_SIZE]; u_char sc_stalled; u_char sc_dying; struct id sc_id; unsigned long *sc_bm[EVT_USED]; int *sc_btn; struct abs_axis *sc_abs; int sc_tool[2]; int sc_tool_id[2]; unsigned int sc_serial[2]; int sc_sync; LIST_HEAD(, uwacom_handler) sc_handlers; }; static eventhandler_tag uwacom_ehtag = NULL; static int uwacom_ehtag_ref = 0; static void uwacom_intr(usbd_xfer_handle, usbd_private_handle, usbd_status); static void uwacom_process_packet(struct uwacom_softc*); void uwacom_pos_events(struct uwacom_softc *sc, int x, int y, int distance); void uwacom_pen_events(struct uwacom_softc *sc, int pressure, int tilt_x, int tilt_y, int touch, int stylus_1, int stylus_2); void uwacom_mouse_events(struct uwacom_softc *sc, int left, int middle, int right, int extra, int side, int wheel); void uwacom_pad_events(struct uwacom_softc *sc, int btn_0, int btn_1, int btn_2, int btn_3, int btn_4, int btn_5, int btn_6, int btn_7, int rx, int ry); void uwacom_tool_events(struct uwacom_softc *sc, int index, int proximity); static void uwacom_event(struct uwacom_softc *sc, unsigned int type, unsigned int index, int value); static int uwacom_init(struct uwacom_softc*, usb_device_descriptor_t *dd); static void uwacom_init_abs(struct uwacom_softc *sc, int axis, int32_t min, int32_t max, int32_t fuzz, int32_t flat); static void uwacom_clone(void *arg, struct ucred *cred, char *name, int namelen, struct cdev **dev); USB_DECLARE_DRIVER(uwacom); USB_MATCH(uwacom) { USB_MATCH_START(uwacom, uaa); if (!uaa->device || !uaa->iface) return UMATCH_NONE; usb_device_descriptor_t *dd = usbd_get_device_descriptor(uaa->device); if (!dd || UGETW(dd->idVendor) != USB_VENDOR_WACOM || UGETW(dd->idProduct) != USB_PRODUCT_WACOM_CINTIQ_21UX) return UMATCH_NONE; return UMATCH_VENDOR_PRODUCT; } USB_ATTACH(uwacom) { USB_ATTACH_START(uwacom, sc, uaa); char devinfo[1024]; usbd_devinfo(uaa->device, 0, devinfo); USB_ATTACH_SETUP; usb_device_descriptor_t *dd = usbd_get_device_descriptor(uaa->device); if (!dd) { printf("%s: could not read device descriptor\n", USBDEVNAME(sc->sc_dev)); sc->sc_dying = 1; return 1; } usb_endpoint_descriptor_t *ed = usbd_interface2endpoint_descriptor(uaa->iface, 0); if (!ed) { printf("%s: could not read endpoint descriptor\n", USBDEVNAME(sc->sc_dev)); sc->sc_dying = 1; USB_ATTACH_ERROR_RETURN; } if (UE_GET_DIR(ed->bEndpointAddress) != UE_DIR_IN || (ed->bmAttributes & UE_XFERTYPE) != UE_INTERRUPT) { printf("%s: unexpected endpoint\n", USBDEVNAME(sc->sc_dev)); sc->sc_dying = 1; USB_ATTACH_ERROR_RETURN; } if (uwacom_init(sc, dd)) USB_ATTACH_ERROR_RETURN; static u_char report[] = {2, 2}; usbd_set_report(uaa->iface, 3, 2, &report, sizeof report); if (!uwacom_ehtag_ref++) uwacom_ehtag = EVENTHANDLER_REGISTER(dev_clone, uwacom_clone, 0, 1000); sc->dev = make_dev(&uwacomphy_cdevsw, MINOR(device_get_unit(self), 0), UID_ROOT, GID_OPERATOR, 0644, "uwacom%d", device_get_unit(self)); sc->sc_iface = uaa->iface; sc->sc_ep_addr = ed->bEndpointAddress; USB_ATTACH_SUCCESS_RETURN; } USB_DETACH(uwacom) { USB_DETACH_START(uwacom, sc); if (--uwacom_ehtag_ref == 0) EVENTHANDLER_DEREGISTER(dev_clone, uwacom_ehtag); sc->sc_dying = 1; if (sc->sc_intrpipe) usbd_abort_pipe(sc->sc_intrpipe); for (int i = 0; i < EVT_USED; ++i) free(sc->sc_bm[i], M_USBDEV); free(sc->sc_btn, M_USBDEV); free(sc->sc_abs, M_USBDEV); destroy_dev(sc->dev); return 0; } int uwacomopen(struct cdev *dev, int flag, int mode, usb_proc_ptr p) { struct uwacom_softc *sc; USB_GET_SC_OPEN(uwacom, TABLET(dev), sc); if (sc->sc_dying) return ENXIO; if (dev->si_drv1) return EBUSY; struct uwacom_handler *handler = malloc(sizeof(struct uwacom_handler), M_USBDEV, M_NOWAIT | M_ZERO); if (!handler) return ENOMEM; if (clalloc(&handler->queue, 0x4000, 0) == -1) { free(handler, M_USBDEV); return ENOMEM; } if ((!sc->sc_intrpipe) && usbd_open_pipe_intr(sc->sc_iface, sc->sc_ep_addr, USBD_SHORT_XFER_OK, &sc->sc_intrpipe, sc, sc->sc_buf, USB_PACKET_SIZE, uwacom_intr, USBD_DEFAULT_INTERVAL)) { clfree(&handler->queue); free(handler, M_USBDEV); return EIO; } dev->si_drv1 = handler; int s = splusb(); LIST_INSERT_HEAD(&sc->sc_handlers, handler, link); splx(s); return 0; } int uwacomclose(struct cdev *dev, int flag, int mode, usb_proc_ptr p) { struct uwacom_softc *sc; USB_GET_SC_OPEN(uwacom, TABLET(dev), sc); struct uwacom_handler *handler = (struct uwacom_handler*)dev->si_drv1; int s = splusb(); LIST_REMOVE(handler, link); splx(s); ndflush(&handler->queue, handler->queue.c_cc); clfree(&handler->queue); funsetown(&handler->queue_sigio); free(handler, M_USBDEV); dev->si_drv1 = NULL; if (LIST_EMPTY(&sc->sc_handlers) && sc->sc_intrpipe) { usbd_abort_pipe(sc->sc_intrpipe); usbd_close_pipe(sc->sc_intrpipe); sc->sc_intrpipe = 0; sc->sc_stalled = 0; } return 0; } int uwacomread(struct cdev *dev, struct uio *uio, int flag) { struct uwacom_softc *sc; USB_GET_SC(uwacom, TABLET(dev), sc); struct uwacom_handler *handler = (struct uwacom_handler*)dev->si_drv1; int error = 0; int s = splusb(); while (!handler->queue.c_cc) { if (flag & O_NONBLOCK) { splx(s); return EWOULDBLOCK; } handler->sleeping = 1; error = tsleep(&handler->queue, PZERO | PCATCH, "uwacom", 0); handler->sleeping = 0; if (sc->sc_dying) error = EIO; if (error) break; if (sc->sc_stalled) { sc->sc_stalled = 0; usbd_clear_endpoint_stall(sc->sc_intrpipe); } } u_char buffer[128]; while (handler->queue.c_cc > 0 && uio->uio_resid > 0 && !error) { size_t length = min(min(handler->queue.c_cc, uio->uio_resid), sizeof(buffer)); q_to_b(&handler->queue, buffer, length); if ((error = uiomove(buffer, length, uio)) != 0) break; } splx(s); return error; } int uwacomioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag, usb_proc_ptr p) { struct uwacom_softc *sc; USB_GET_SC(uwacom, TABLET(dev), sc); if (sc->sc_dying) return EIO; struct uwacom_handler *handler = (struct uwacom_handler*)dev->si_drv1; switch (cmd) { case FIONREAD: { int s = splusb(); *(int*)addr = handler->queue.c_cc; splx(s); break; } case FIONBIO: break; case FIOASYNC: handler->async = *(int*)addr; break; case FIOSETOWN: return fsetown(*(int*)addr, &handler->queue_sigio); default: { int num = cmd & 0xff; int len = IOCPARM_LEN(cmd); if (IOCGROUP(cmd) != 'E' || (cmd & IOC_DIRMASK) != IOC_OUT) return EINVAL; switch (num) { case EUWACOMGETVERSION: if (len != sizeof(int)) return EINVAL; *(int*)addr = 0x00010000; break; case EUWACOMGETID: if (len != sizeof(struct id)) return EINVAL; memcpy(addr, &sc->sc_id, sizeof(struct id)); break; default: if (num >= EUWACOMGETBM && num < EUWACOMGETBM + EVT_USED) { int idx = num - EUWACOMGETBM; size_t length = min(bm_size[idx], len); memcpy(addr, sc->sc_bm[idx], length); // Returning a positive value from an ioctl is somewhat of a gamble // Sometimes it has to be in td_retval[0], sometimes in td_retval[1] p->td_retval[0] = length; p->td_retval[1] = length; return 0; } else if (num >= EUWACOMGETABS && num < EUWACOMGETABS + ABS_USED) { if (len != sizeof(struct abs_axis)) return EINVAL; int idx = num - EUWACOMGETABS; memcpy(addr, &sc->sc_abs[idx], sizeof(struct abs_axis)); } else return EINVAL; } } } return 0; } int uwacompoll(struct cdev *dev, int events, usb_proc_ptr p) { struct uwacom_softc *sc; USB_GET_SC(uwacom, TABLET(dev), sc); struct uwacom_handler *handler = (struct uwacom_handler*)dev->si_drv1; if (sc->sc_dying) return EIO; int revents = 0; if (events & (POLLIN | POLLRDNORM)) { int s = splusb(); if (handler->queue.c_cc) revents = events & (POLLIN | POLLRDNORM); else selrecord(p, &handler->rsel); splx(s); } return revents; } void uwacompurge(struct cdev *dev) { struct uwacom_handler *handler = (struct uwacom_handler*)dev->si_drv1; if (handler->sleeping) wakeup(&handler->queue); selwakeuppri(&handler->rsel, PZERO); } static void uwacom_intr(usbd_xfer_handle xfer, usbd_private_handle addr, usbd_status status) { struct uwacom_softc *sc = addr; if (status == USBD_CANCELLED) return; if (status != USBD_NORMAL_COMPLETION) { if (status == USBD_STALLED) sc->sc_stalled = 1; return; } uwacom_process_packet(sc); struct uwacom_handler *handler; LIST_FOREACH(handler, &sc->sc_handlers, link) if (handler->queue.c_cc) { if (handler->sleeping) { handler->sleeping = 0; wakeup(&handler->queue); } selwakeuppri(&handler->rsel, PZERO); if (handler->async && handler->queue_sigio) pgsigio(&handler->queue_sigio, SIGIO, 0); } } static void uwacom_process_packet(struct uwacom_softc *sc) { u_char *packet = sc->sc_buf; switch (PACKET_BITS(0, 0, 8)) { case 0x02: { int index = PACKET_BIT(1, 0); // Tool entering proximity if (PACKET_BITS(1, 2, 6) == 0x30) { sc->sc_tool_id[index] = PACKET_BITS(3, 4, 12); sc->sc_serial[index] = PACKET_BITS(7, 4, 32); switch (sc->sc_tool_id[index]) { case 0x823: sc->sc_tool[index] = BTN_TOOL_PEN; break; case 0x82b: sc->sc_tool[index] = BTN_TOOL_ERASER; break; case 0x017: sc->sc_tool[index] = BTN_TOOL_MOUSE; break; default: sc->sc_tool[index] = BTN_TOOL_PEN; } // Tool leaving proximity } else if (PACKET_BITS(1, 1, 7) == 0x40) { uwacom_pos_events(sc, 0, 0, 0); if (sc->sc_tool[index] == BTN_TOOL_MOUSE) uwacom_mouse_events(sc, 0, 0, 0, 0, 0, 0); else uwacom_pen_events(sc, 0, 0, 0, 0, 0, 0); sc->sc_tool_id[index] = 0; uwacom_tool_events(sc, index, 0); // Standard packet with ready bit set } else if (PACKET_BIT(1, 6)) { uwacom_pos_events(sc, (PACKET_BITS(3, 0, 16) << 1) | PACKET_BIT(9, 1), (PACKET_BITS(5, 0, 16) << 1) | PACKET_BIT(9, 0), PACKET_BITS(9, 2, 6)); if (PACKET_BIT(1, 7)) { if (PACKET_BITS(1, 3, 3) == 0x04) uwacom_pen_events(sc, PACKET_BITS(7, 6, 10), PACKET_BITS(8, 7, 7), PACKET_BITS(8, 0, 7), PACKET_BITS(7, 6, 10) > 10, PACKET_BIT(1, 1), PACKET_BIT(1, 2)); else if (PACKET_BITS(1, 1, 5) == 0x18 && sc->sc_tool[index] == BTN_TOOL_MOUSE) uwacom_mouse_events(sc, PACKET_BIT(8, 2), PACKET_BIT(8, 3), PACKET_BIT(8, 4), PACKET_BIT(8, 5), PACKET_BIT(8, 6), PACKET_BIT(8, 0) - PACKET_BIT(8, 1)); } uwacom_tool_events(sc, index, 1); } break; } case 0x0c: uwacom_pad_events(sc, PACKET_BIT(5, 0), PACKET_BIT(5, 1), PACKET_BIT(5, 2), PACKET_BIT(5, 3), PACKET_BIT(6, 0), PACKET_BIT(6, 1), PACKET_BIT(6, 2), PACKET_BIT(6, 3), PACKET_BITS(2, 0, 13), PACKET_BITS(4, 0, 13)); sc->sc_tool[1] = BTN_TOOL_FINGER; sc->sc_tool_id[1] = TOOL_ID_FINGER; sc->sc_serial[1] = SERIAL_FINGER; uwacom_tool_events(sc, 1, PACKET_BITS(5, 0, 4) || PACKET_BITS(6, 0, 4) || PACKET_BITS(2, 0, 13) || PACKET_BITS(4, 0, 13)); break; default: printf("%s: unknown report type %02x received\n", USBDEVNAME(sc->sc_dev), PACKET_BITS(0, 0, 8)); } } void uwacom_pos_events(struct uwacom_softc *sc, int x, int y, int distance) { uwacom_event(sc, EVT_ABS, ABS_X, x); uwacom_event(sc, EVT_ABS, ABS_Y, y); uwacom_event(sc, EVT_ABS, ABS_DISTANCE, distance); } void uwacom_pen_events(struct uwacom_softc *sc, int pressure, int tilt_x, int tilt_y, int touch, int stylus_1, int stylus_2) { uwacom_event(sc, EVT_ABS, ABS_PRESSURE, pressure); uwacom_event(sc, EVT_ABS, ABS_TILT_X, tilt_x); uwacom_event(sc, EVT_ABS, ABS_TILT_Y, tilt_y); uwacom_event(sc, EVT_BTN, BTN_TOUCH, touch); uwacom_event(sc, EVT_BTN, BTN_STYLUS_1, stylus_1); uwacom_event(sc, EVT_BTN, BTN_STYLUS_2, stylus_2); } void uwacom_mouse_events(struct uwacom_softc *sc, int left, int middle, int right, int extra, int side, int wheel) { uwacom_event(sc, EVT_BTN, BTN_LEFT, left); uwacom_event(sc, EVT_BTN, BTN_MIDDLE, middle); uwacom_event(sc, EVT_BTN, BTN_RIGHT, right); uwacom_event(sc, EVT_BTN, BTN_EXTRA, extra); uwacom_event(sc, EVT_BTN, BTN_SIDE, side); uwacom_event(sc, EVT_REL, REL_WHEEL, wheel); } void uwacom_pad_events(struct uwacom_softc *sc, int btn_0, int btn_1, int btn_2, int btn_3, int btn_4, int btn_5, int btn_6, int btn_7, int rx, int ry) { uwacom_event(sc, EVT_BTN, BTN_MISC_0, btn_0); uwacom_event(sc, EVT_BTN, BTN_MISC_1, btn_1); uwacom_event(sc, EVT_BTN, BTN_MISC_2, btn_2); uwacom_event(sc, EVT_BTN, BTN_MISC_3, btn_3); uwacom_event(sc, EVT_BTN, BTN_MISC_4, btn_4); uwacom_event(sc, EVT_BTN, BTN_MISC_5, btn_5); uwacom_event(sc, EVT_BTN, BTN_MISC_6, btn_6); uwacom_event(sc, EVT_BTN, BTN_MISC_7, btn_7); uwacom_event(sc, EVT_ABS, ABS_RX, rx); uwacom_event(sc, EVT_ABS, ABS_RY, ry); } void uwacom_tool_events(struct uwacom_softc *sc, int index, int proximity) { uwacom_event(sc, EVT_BTN, sc->sc_tool[index], proximity); uwacom_event(sc, EVT_ABS, ABS_MISC, sc->sc_tool_id[index]); uwacom_event(sc, EVT_MSC, MSC_SERIAL, sc->sc_serial[index]); uwacom_event(sc, EVT_SYN, SYN_REPORT, 0); } static void uwacom_event(struct uwacom_softc *sc, unsigned int type, unsigned int index, int value) { switch (type) { case EVT_SYN: if (sc->sc_sync) return; break; case EVT_BTN: if (sc->sc_btn[index] == value) return; sc->sc_btn[index] = value; break; case EVT_ABS: if (sc->sc_abs[index].fuzz) { int dist = abs(value - sc->sc_abs[index].value); if (dist < sc->sc_abs[index].fuzz >> 1) return; else if (dist < sc->sc_abs[index].fuzz) value = (7 * sc->sc_abs[index].value + value) >> 3; else if (dist < sc->sc_abs[index].fuzz << 1) value = (sc->sc_abs[index].value + value) >> 1; } if (sc->sc_abs[index].value == value) return; sc->sc_abs[index].value = value; break; case EVT_REL: if (!value) return; break; case EVT_MSC: break; default: return; } struct event ev; microtime(&ev.time); ev.type = type; ev.index = index; ev.value = value; struct uwacom_handler *handler; LIST_FOREACH(handler, &sc->sc_handlers, link) if (b_to_q((char*)&ev, sizeof(struct event), &handler->queue)) printf("%s: event queue overflow\n", USBDEVNAME(sc->sc_dev)); sc->sc_sync = (type == EVT_SYN); } static int uwacom_init(struct uwacom_softc *sc, usb_device_descriptor_t *dd) { sc->sc_id.bus = ID_BUS_USB; sc->sc_id.vendor = le16toh(UGETW(dd->idVendor)); sc->sc_id.product = le16toh(UGETW(dd->idProduct)); sc->sc_id.version = le16toh(UGETW(dd->bcdDevice)); for (int i = 0; i < EVT_USED; ++i) if (!(sc->sc_bm[i] = malloc(bm_size[i], M_USBDEV, M_NOWAIT | M_ZERO))) goto nomem; if (!(sc->sc_btn = malloc(BTN_USED * sizeof(int), M_USBDEV, M_NOWAIT | M_ZERO))) goto nomem; if (!(sc->sc_abs = malloc(ABS_USED * sizeof(struct abs_axis), M_USBDEV, M_NOWAIT | M_ZERO))) goto nomem; BM_SET_BIT(sc->sc_bm[0], EVT_SYN); BM_SET_BIT(sc->sc_bm[0], EVT_BTN); BM_SET_BIT(sc->sc_bm[0], EVT_REL); BM_SET_BIT(sc->sc_bm[0], EVT_ABS); BM_SET_BIT(sc->sc_bm[0], EVT_MSC); BM_SET_BIT(sc->sc_bm[1], BTN_MISC_0); BM_SET_BIT(sc->sc_bm[1], BTN_MISC_1); BM_SET_BIT(sc->sc_bm[1], BTN_MISC_2); BM_SET_BIT(sc->sc_bm[1], BTN_MISC_3); BM_SET_BIT(sc->sc_bm[1], BTN_MISC_4); BM_SET_BIT(sc->sc_bm[1], BTN_MISC_5); BM_SET_BIT(sc->sc_bm[1], BTN_MISC_6); BM_SET_BIT(sc->sc_bm[1], BTN_MISC_7); BM_SET_BIT(sc->sc_bm[1], BTN_LEFT); BM_SET_BIT(sc->sc_bm[1], BTN_RIGHT); BM_SET_BIT(sc->sc_bm[1], BTN_MIDDLE); BM_SET_BIT(sc->sc_bm[1], BTN_SIDE); BM_SET_BIT(sc->sc_bm[1], BTN_EXTRA); BM_SET_BIT(sc->sc_bm[1], BTN_TOOL_PEN); BM_SET_BIT(sc->sc_bm[1], BTN_TOOL_ERASER); BM_SET_BIT(sc->sc_bm[1], BTN_TOOL_FINGER); BM_SET_BIT(sc->sc_bm[1], BTN_TOOL_MOUSE); BM_SET_BIT(sc->sc_bm[1], BTN_TOUCH); BM_SET_BIT(sc->sc_bm[1], BTN_STYLUS_1); BM_SET_BIT(sc->sc_bm[1], BTN_STYLUS_2); BM_SET_BIT(sc->sc_bm[2], REL_WHEEL); BM_SET_BIT(sc->sc_bm[3], ABS_X); BM_SET_BIT(sc->sc_bm[3], ABS_Y); BM_SET_BIT(sc->sc_bm[3], ABS_RX); BM_SET_BIT(sc->sc_bm[3], ABS_RY); BM_SET_BIT(sc->sc_bm[3], ABS_PRESSURE); BM_SET_BIT(sc->sc_bm[3], ABS_DISTANCE); BM_SET_BIT(sc->sc_bm[3], ABS_TILT_X); BM_SET_BIT(sc->sc_bm[3], ABS_TILT_Y); BM_SET_BIT(sc->sc_bm[3], ABS_MISC); BM_SET_BIT(sc->sc_bm[4], MSC_SERIAL); uwacom_init_abs(sc, ABS_X, 0, 87200, 4, 0); uwacom_init_abs(sc, ABS_Y, 0, 65600, 4, 0); uwacom_init_abs(sc, ABS_RX, 0, 4096, 0, 0); uwacom_init_abs(sc, ABS_RY, 0, 4096, 0, 0); uwacom_init_abs(sc, ABS_PRESSURE, 0, 1023, 0, 0); uwacom_init_abs(sc, ABS_DISTANCE, 0, 63, 0, 0); uwacom_init_abs(sc, ABS_TILT_X, 0, 127, 0, 0); uwacom_init_abs(sc, ABS_TILT_Y, 0, 127, 0, 0); return 0; nomem: printf("%s: out of memory\n", USBDEVNAME(sc->sc_dev)); sc->sc_dying = 1; return 1; } static void uwacom_init_abs(struct uwacom_softc *sc, int axis, int32_t min, int32_t max, int32_t fuzz, int32_t flat) { sc->sc_abs[axis].min = min; sc->sc_abs[axis].max = max; sc->sc_abs[axis].fuzz = fuzz; sc->sc_abs[axis].flat = flat; } static void uwacom_clone(void *arg, struct ucred *cred, char *name, int namelen, struct cdev **dev) { if (*dev) return; int tablet; if (dev_stdclone(name, NULL, "event", &tablet) != 1) return; struct uwacom_softc *sc = devclass_get_softc(uwacom_devclass, tablet); if (!sc || sc->sc_dying) return; struct cdev *dev_handler; int max = -1; LIST_FOREACH(dev_handler, &sc->dev->si_children, si_siblings) if (!dev_handler->si_drv1) { *dev = dev_handler; return; } else if (HANDLER(dev_handler) > max) max = HANDLER(dev_handler); int handler; int *map = malloc((max + 1) * sizeof(int), M_USBDEV, M_NOWAIT | M_ZERO); if (map) { LIST_FOREACH(dev_handler, &sc->dev->si_children, si_siblings) map[HANDLER(dev_handler)] = 1; for (handler = 0; handler <= max; ++handler) if (!map[handler]) break; free(map, M_USBDEV); } else handler = max + 1; if (handler > HANDLER_MAX) return; *dev = make_dev(&uwacom_cdevsw, MINOR(tablet, handler), UID_ROOT, GID_OPERATOR, 0644, "%s.%d", name, handler); dev_depends(sc->dev, *dev); (*dev)->si_flags |= SI_CHEAPCLONE; (*dev)->si_drv1 = NULL; } DRIVER_MODULE(uwacom, uhub, uwacom_driver, uwacom_devclass, usbd_driver_load, NULL); bsdwacom/uwacom/Makefile 000644 001751 000000 00000000121 10702725562 015707 0 ustar 00undo wheel 000000 000000 KMOD= uwacom SRCS= uwacom.c SRCS+= device_if.h bus_if.h .include <bsd.kmod.mk> bsdwacom/uwacom/opt_usb.h 000644 001751 000000 00000000000 10702725565 016072 0 ustar 00undo wheel 000000 000000 bsdwacom/linuxwacom/files/ 000755 001751 000000 00000000000 10702727606 016253 5 ustar 00undo wheel 000000 000000 bsdwacom/linuxwacom/run_configure 000755 001751 000000 00000001352 10702727636 017750 0 ustar 00undo wheel 000000 000000 #!/bin/sh rm -rf linuxwacom-0.7.8-3 tar xf linuxwacom-0.7.8-3.tar.bz2 patch < patch_linuxwacom-0.7.8-3 mkdir linuxwacom-0.7.8-3/src/util/asm mkdir linuxwacom-0.7.8-3/src/util/linux mkdir linuxwacom-0.7.8-3/src/xdrv/asm mkdir linuxwacom-0.7.8-3/src/xdrv/linux cp files/types.h linuxwacom-0.7.8-3/src/util/asm cp files/input.h linuxwacom-0.7.8-3/src/util/linux cp files/types.h linuxwacom-0.7.8-3/src/xdrv/asm cp files/input.h linuxwacom-0.7.8-3/src/xdrv/linux cd linuxwacom-0.7.8-3 ./configure --with-xorg-sdk=/usr/local --with-xlib=/usr/local/lib --with-tcl=/usr/local/include/tcl8.4 --with-tk=/usr/local/include/tk8.4 --with-linux=yes --with-xmoduledir=/usr/local/lib/xorg/modules/input CFLAGS="-I/usr/local/include" LDFLAGS="-I/usr/local/lib" bsdwacom/linuxwacom/patch_linuxwacom-0.7.8-3 000644 001751 000000 00000001767 10702725764 021267 0 ustar 00undo wheel 000000 000000 diff -ruN linuxwacom-0.7.8-3.orig/src/xdrv/Makefile.am linuxwacom-0.7.8-3/src/xdrv/Makefile.am --- linuxwacom-0.7.8-3.orig/src/xdrv/Makefile.am 2007-08-15 00:12:39.000000000 +0100 +++ linuxwacom-0.7.8-3/src/xdrv/Makefile.am 2007-10-09 16:07:21.000000000 +0100 @@ -49,7 +49,7 @@ DLLOADER=-fPIC endif -CFLAGS += $(WCM_CFLAGS_STACK_PROTECTOR) -Wno-variadic-macros +CFLAGS += $(WCM_CFLAGS_STACK_PROTECTOR) XF86OBJS = xf86Wacom.o wcmSerial.o wcmUSB.o wcmISDV4.o \ wcmXCommand.o wcmCommon.o wcmCompat.o wcmConfig.o \ diff -ruN linuxwacom-0.7.8-3.orig/src/xdrv/Makefile.in linuxwacom-0.7.8-3/src/xdrv/Makefile.in --- linuxwacom-0.7.8-3.orig/src/xdrv/Makefile.in 2007-08-15 00:12:39.000000000 +0100 +++ linuxwacom-0.7.8-3/src/xdrv/Makefile.in 2007-10-09 16:07:26.000000000 +0100 @@ -71,7 +71,7 @@ AWK = @AWK@ CC = @CC@ CCDEPMODE = @CCDEPMODE@ -CFLAGS = @CFLAGS@ $(WCM_CFLAGS_STACK_PROTECTOR) -Wno-variadic-macros +CFLAGS = @CFLAGS@ $(WCM_CFLAGS_STACK_PROTECTOR) CPP = @CPP@ CPPFLAGS = @CPPFLAGS@ CXX = @CXX@ bsdwacom/linuxwacom/files/types.h 000644 001751 000000 00000000377 10702725753 017600 0 ustar 00undo wheel 000000 000000 #ifndef _TYPES_H #define _TYPES_H #include <sys/types.h> typedef int8_t __s8; typedef uint8_t __u8; typedef int16_t __s16; typedef uint16_t __u16; typedef int32_t __s32; typedef uint32_t __u32; typedef int64_t __s64; typedef uint64_t __u64; #endif bsdwacom/linuxwacom/files/input.h 000644 001751 000000 00000075233 10702725753 017576 0 ustar 00undo wheel 000000 000000 #ifndef _INPUT_H #define _INPUT_H /* * Copyright (c) 1999-2002 Vojtech Pavlik * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 as published by * the Free Software Foundation. */ #ifdef __KERNEL__ #include <linux/time.h> #include <linux/list.h> #else #include <sys/time.h> #include <sys/ioctl.h> #include <sys/types.h> #include <asm/types.h> #endif /* * The event structure itself */ struct input_event { struct timeval time; __u16 type; __u16 code; __s32 value; }; /* * Protocol version. */ #define EV_VERSION 0x010000 /* * IOCTLs (0x00 - 0x7f) */ struct input_id { __u16 bustype; __u16 vendor; __u16 product; __u16 version; }; struct input_absinfo { __s32 value; __s32 minimum; __s32 maximum; __s32 fuzz; __s32 flat; }; #ifndef _IOC_READ #define _IOC_READ IOC_OUT #endif #define EVIOCGVERSION _IOR('E', 0x01, int) /* get driver version */ #define EVIOCGID _IOR('E', 0x02, struct input_id) /* get device ID */ #define EVIOCGREP _IOR('E', 0x03, int[2]) /* get repeat settings */ #define EVIOCSREP _IOW('E', 0x03, int[2]) /* set repeat settings */ #define EVIOCGKEYCODE _IOR('E', 0x04, int[2]) /* get keycode */ #define EVIOCSKEYCODE _IOW('E', 0x04, int[2]) /* set keycode */ #define EVIOCGNAME(len) _IOC(_IOC_READ, 'E', 0x06, len) /* get device name */ #define EVIOCGPHYS(len) _IOC(_IOC_READ, 'E', 0x07, len) /* get physical location */ #define EVIOCGUNIQ(len) _IOC(_IOC_READ, 'E', 0x08, len) /* get unique identifier */ #define EVIOCGKEY(len) _IOC(_IOC_READ, 'E', 0x18, len) /* get global keystate */ #define EVIOCGLED(len) _IOC(_IOC_READ, 'E', 0x19, len) /* get all LEDs */ #define EVIOCGSND(len) _IOC(_IOC_READ, 'E', 0x1a, len) /* get all sounds status */ #define EVIOCGSW(len) _IOC(_IOC_READ, 'E', 0x1b, len) /* get all switch states */ #define EVIOCGBIT(ev,len) _IOC(_IOC_READ, 'E', 0x20 + ev, len) /* get event bits */ #define EVIOCGABS(abs) _IOR('E', 0x40 + abs, struct input_absinfo) /* get abs value/limits */ #define EVIOCSABS(abs) _IOW('E', 0xc0 + abs, struct input_absinfo) /* set abs value/limits */ #define EVIOCSFF _IOC(_IOC_WRITE, 'E', 0x80, sizeof(struct ff_effect)) /* send a force effect to a force feedback device */ #define EVIOCRMFF _IOW('E', 0x81, int) /* Erase a force effect */ #define EVIOCGEFFECTS _IOR('E', 0x84, int) /* Report number of effects playable at the same time */ #define EVIOCGRAB _IOW('E', 0x90, int) /* Grab/Release device */ /* * Event types */ #define EV_SYN 0x00 #define EV_KEY 0x01 #define EV_REL 0x02 #define EV_ABS 0x03 #define EV_MSC 0x04 #define EV_SW 0x05 #define EV_LED 0x11 #define EV_SND 0x12 #define EV_REP 0x14 #define EV_FF 0x15 #define EV_PWR 0x16 #define EV_FF_STATUS 0x17 #define EV_MAX 0x1f /* * Synchronization events. */ #define SYN_REPORT 0 #define SYN_CONFIG 1 /* * Keys and buttons */ #define KEY_RESERVED 0 #define KEY_ESC 1 #define KEY_1 2 #define KEY_2 3 #define KEY_3 4 #define KEY_4 5 #define KEY_5 6 #define KEY_6 7 #define KEY_7 8 #define KEY_8 9 #define KEY_9 10 #define KEY_0 11 #define KEY_MINUS 12 #define KEY_EQUAL 13 #define KEY_BACKSPACE 14 #define KEY_TAB 15 #define KEY_Q 16 #define KEY_W 17 #define KEY_E 18 #define KEY_R 19 #define KEY_T 20 #define KEY_Y 21 #define KEY_U 22 #define KEY_I 23 #define KEY_O 24 #define KEY_P 25 #define KEY_LEFTBRACE 26 #define KEY_RIGHTBRACE 27 #define KEY_ENTER 28 #define KEY_LEFTCTRL 29 #define KEY_A 30 #define KEY_S 31 #define KEY_D 32 #define KEY_F 33 #define KEY_G 34 #define KEY_H 35 #define KEY_J 36 #define KEY_K 37 #define KEY_L 38 #define KEY_SEMICOLON 39 #define KEY_APOSTROPHE 40 #define KEY_GRAVE 41 #define KEY_LEFTSHIFT 42 #define KEY_BACKSLASH 43 #define KEY_Z 44 #define KEY_X 45 #define KEY_C 46 #define KEY_V 47 #define KEY_B 48 #define KEY_N 49 #define KEY_M 50 #define KEY_COMMA 51 #define KEY_DOT 52 #define KEY_SLASH 53 #define KEY_RIGHTSHIFT 54 #define KEY_KPASTERISK 55 #define KEY_LEFTALT 56 #define KEY_SPACE 57 #define KEY_CAPSLOCK 58 #define KEY_F1 59 #define KEY_F2 60 #define KEY_F3 61 #define KEY_F4 62 #define KEY_F5 63 #define KEY_F6 64 #define KEY_F7 65 #define KEY_F8 66 #define KEY_F9 67 #define KEY_F10 68 #define KEY_NUMLOCK 69 #define KEY_SCROLLLOCK 70 #define KEY_KP7 71 #define KEY_KP8 72 #define KEY_KP9 73 #define KEY_KPMINUS 74 #define KEY_KP4 75 #define KEY_KP5 76 #define KEY_KP6 77 #define KEY_KPPLUS 78 #define KEY_KP1 79 #define KEY_KP2 80 #define KEY_KP3 81 #define KEY_KP0 82 #define KEY_KPDOT 83 #define KEY_ZENKAKUHANKAKU 85 #define KEY_102ND 86 #define KEY_F11 87 #define KEY_F12 88 #define KEY_RO 89 #define KEY_KATAKANA 90 #define KEY_HIRAGANA 91 #define KEY_HENKAN 92 #define KEY_KATAKANAHIRAGANA 93 #define KEY_MUHENKAN 94 #define KEY_KPJPCOMMA 95 #define KEY_KPENTER 96 #define KEY_RIGHTCTRL 97 #define KEY_KPSLASH 98 #define KEY_SYSRQ 99 #define KEY_RIGHTALT 100 #define KEY_LINEFEED 101 #define KEY_HOME 102 #define KEY_UP 103 #define KEY_PAGEUP 104 #define KEY_LEFT 105 #define KEY_RIGHT 106 #define KEY_END 107 #define KEY_DOWN 108 #define KEY_PAGEDOWN 109 #define KEY_INSERT 110 #define KEY_DELETE 111 #define KEY_MACRO 112 #define KEY_MUTE 113 #define KEY_VOLUMEDOWN 114 #define KEY_VOLUMEUP 115 #define KEY_POWER 116 #define KEY_KPEQUAL 117 #define KEY_KPPLUSMINUS 118 #define KEY_PAUSE 119 #define KEY_KPCOMMA 121 #define KEY_HANGEUL 122 #define KEY_HANGUEL KEY_HANGEUL #define KEY_HANJA 123 #define KEY_YEN 124 #define KEY_LEFTMETA 125 #define KEY_RIGHTMETA 126 #define KEY_COMPOSE 127 #define KEY_STOP 128 #define KEY_AGAIN 129 #define KEY_PROPS 130 #define KEY_UNDO 131 #define KEY_FRONT 132 #define KEY_COPY 133 #define KEY_OPEN 134 #define KEY_PASTE 135 #define KEY_FIND 136 #define KEY_CUT 137 #define KEY_HELP 138 #define KEY_MENU 139 #define KEY_CALC 140 #define KEY_SETUP 141 #define KEY_SLEEP 142 #define KEY_WAKEUP 143 #define KEY_FILE 144 #define KEY_SENDFILE 145 #define KEY_DELETEFILE 146 #define KEY_XFER 147 #define KEY_PROG1 148 #define KEY_PROG2 149 #define KEY_WWW 150 #define KEY_MSDOS 151 #define KEY_COFFEE 152 #define KEY_DIRECTION 153 #define KEY_CYCLEWINDOWS 154 #define KEY_MAIL 155 #define KEY_BOOKMARKS 156 #define KEY_COMPUTER 157 #define KEY_BACK 158 #define KEY_FORWARD 159 #define KEY_CLOSECD 160 #define KEY_EJECTCD 161 #define KEY_EJECTCLOSECD 162 #define KEY_NEXTSONG 163 #define KEY_PLAYPAUSE 164 #define KEY_PREVIOUSSONG 165 #define KEY_STOPCD 166 #define KEY_RECORD 167 #define KEY_REWIND 168 #define KEY_PHONE 169 #define KEY_ISO 170 #define KEY_CONFIG 171 #define KEY_HOMEPAGE 172 #define KEY_REFRESH 173 #define KEY_EXIT 174 #define KEY_MOVE 175 #define KEY_EDIT 176 #define KEY_SCROLLUP 177 #define KEY_SCROLLDOWN 178 #define KEY_KPLEFTPAREN 179 #define KEY_KPRIGHTPAREN 180 #define KEY_NEW 181 #define KEY_REDO 182 #define KEY_F13 183 #define KEY_F14 184 #define KEY_F15 185 #define KEY_F16 186 #define KEY_F17 187 #define KEY_F18 188 #define KEY_F19 189 #define KEY_F20 190 #define KEY_F21 191 #define KEY_F22 192 #define KEY_F23 193 #define KEY_F24 194 #define KEY_PLAYCD 200 #define KEY_PAUSECD 201 #define KEY_PROG3 202 #define KEY_PROG4 203 #define KEY_SUSPEND 205 #define KEY_CLOSE 206 #define KEY_PLAY 207 #define KEY_FASTFORWARD 208 #define KEY_BASSBOOST 209 #define KEY_PRINT 210 #define KEY_HP 211 #define KEY_CAMERA 212 #define KEY_SOUND 213 #define KEY_QUESTION 214 #define KEY_EMAIL 215 #define KEY_CHAT 216 #define KEY_SEARCH 217 #define KEY_CONNECT 218 #define KEY_FINANCE 219 #define KEY_SPORT 220 #define KEY_SHOP 221 #define KEY_ALTERASE 222 #define KEY_CANCEL 223 #define KEY_BRIGHTNESSDOWN 224 #define KEY_BRIGHTNESSUP 225 #define KEY_MEDIA 226 #define KEY_SWITCHVIDEOMODE 227 #define KEY_KBDILLUMTOGGLE 228 #define KEY_KBDILLUMDOWN 229 #define KEY_KBDILLUMUP 230 #define KEY_SEND 231 #define KEY_REPLY 232 #define KEY_FORWARDMAIL 233 #define KEY_SAVE 234 #define KEY_DOCUMENTS 235 #define KEY_BATTERY 236 #define KEY_BLUETOOTH 237 #define KEY_WLAN 238 #define KEY_UNKNOWN 240 #define BTN_MISC 0x100 #define BTN_0 0x100 #define BTN_1 0x101 #define BTN_2 0x102 #define BTN_3 0x103 #define BTN_4 0x104 #define BTN_5 0x105 #define BTN_6 0x106 #define BTN_7 0x107 #define BTN_8 0x108 #define BTN_9 0x109 #define BTN_MOUSE 0x110 #define BTN_LEFT 0x110 #define BTN_RIGHT 0x111 #define BTN_MIDDLE 0x112 #define BTN_SIDE 0x113 #define BTN_EXTRA 0x114 #define BTN_FORWARD 0x115 #define BTN_BACK 0x116 #define BTN_TASK 0x117 #define BTN_JOYSTICK 0x120 #define BTN_TRIGGER 0x120 #define BTN_THUMB 0x121 #define BTN_THUMB2 0x122 #define BTN_TOP 0x123 #define BTN_TOP2 0x124 #define BTN_PINKIE 0x125 #define BTN_BASE 0x126 #define BTN_BASE2 0x127 #define BTN_BASE3 0x128 #define BTN_BASE4 0x129 #define BTN_BASE5 0x12a #define BTN_BASE6 0x12b #define BTN_DEAD 0x12f #define BTN_GAMEPAD 0x130 #define BTN_A 0x130 #define BTN_B 0x131 #define BTN_C 0x132 #define BTN_X 0x133 #define BTN_Y 0x134 #define BTN_Z 0x135 #define BTN_TL 0x136 #define BTN_TR 0x137 #define BTN_TL2 0x138 #define BTN_TR2 0x139 #define BTN_SELECT 0x13a #define BTN_START 0x13b #define BTN_MODE 0x13c #define BTN_THUMBL 0x13d #define BTN_THUMBR 0x13e #define BTN_DIGI 0x140 #define BTN_TOOL_PEN 0x140 #define BTN_TOOL_RUBBER 0x141 #define BTN_TOOL_BRUSH 0x142 #define BTN_TOOL_PENCIL 0x143 #define BTN_TOOL_AIRBRUSH 0x144 #define BTN_TOOL_FINGER 0x145 #define BTN_TOOL_MOUSE 0x146 #define BTN_TOOL_LENS 0x147 #define BTN_TOUCH 0x14a #define BTN_STYLUS 0x14b #define BTN_STYLUS2 0x14c #define BTN_TOOL_DOUBLETAP 0x14d #define BTN_TOOL_TRIPLETAP 0x14e #define BTN_WHEEL 0x150 #define BTN_GEAR_DOWN 0x150 #define BTN_GEAR_UP 0x151 #define KEY_OK 0x160 #define KEY_SELECT 0x161 #define KEY_GOTO 0x162 #define KEY_CLEAR 0x163 #define KEY_POWER2 0x164 #define KEY_OPTION 0x165 #define KEY_INFO 0x166 #define KEY_TIME 0x167 #define KEY_VENDOR 0x168 #define KEY_ARCHIVE 0x169 #define KEY_PROGRAM 0x16a #define KEY_CHANNEL 0x16b #define KEY_FAVORITES 0x16c #define KEY_EPG 0x16d #define KEY_PVR 0x16e #define KEY_MHP 0x16f #define KEY_LANGUAGE 0x170 #define KEY_TITLE 0x171 #define KEY_SUBTITLE 0x172 #define KEY_ANGLE 0x173 #define KEY_ZOOM 0x174 #define KEY_MODE 0x175 #define KEY_KEYBOARD 0x176 #define KEY_SCREEN 0x177 #define KEY_PC 0x178 #define KEY_TV 0x179 #define KEY_TV2 0x17a #define KEY_VCR 0x17b #define KEY_VCR2 0x17c #define KEY_SAT 0x17d #define KEY_SAT2 0x17e #define KEY_CD 0x17f #define KEY_TAPE 0x180 #define KEY_RADIO 0x181 #define KEY_TUNER 0x182 #define KEY_PLAYER 0x183 #define KEY_TEXT 0x184 #define KEY_DVD 0x185 #define KEY_AUX 0x186 #define KEY_MP3 0x187 #define KEY_AUDIO 0x188 #define KEY_VIDEO 0x189 #define KEY_DIRECTORY 0x18a #define KEY_LIST 0x18b #define KEY_MEMO 0x18c #define KEY_CALENDAR 0x18d #define KEY_RED 0x18e #define KEY_GREEN 0x18f #define KEY_YELLOW 0x190 #define KEY_BLUE 0x191 #define KEY_CHANNELUP 0x192 #define KEY_CHANNELDOWN 0x193 #define KEY_FIRST 0x194 #define KEY_LAST 0x195 #define KEY_AB 0x196 #define KEY_NEXT 0x197 #define KEY_RESTART 0x198 #define KEY_SLOW 0x199 #define KEY_SHUFFLE 0x19a #define KEY_BREAK 0x19b #define KEY_PREVIOUS 0x19c #define KEY_DIGITS 0x19d #define KEY_TEEN 0x19e #define KEY_TWEN 0x19f #define KEY_VIDEOPHONE 0x1a0 #define KEY_GAMES 0x1a1 #define KEY_ZOOMIN 0x1a2 #define KEY_ZOOMOUT 0x1a3 #define KEY_ZOOMRESET 0x1a4 #define KEY_WORDPROCESSOR 0x1a5 #define KEY_EDITOR 0x1a6 #define KEY_SPREADSHEET 0x1a7 #define KEY_GRAPHICSEDITOR 0x1a8 #define KEY_PRESENTATION 0x1a9 #define KEY_DATABASE 0x1aa #define KEY_NEWS 0x1ab #define KEY_VOICEMAIL 0x1ac #define KEY_ADDRESSBOOK 0x1ad #define KEY_MESSENGER 0x1ae #define KEY_DEL_EOL 0x1c0 #define KEY_DEL_EOS 0x1c1 #define KEY_INS_LINE 0x1c2 #define KEY_DEL_LINE 0x1c3 #define KEY_FN 0x1d0 #define KEY_FN_ESC 0x1d1 #define KEY_FN_F1 0x1d2 #define KEY_FN_F2 0x1d3 #define KEY_FN_F3 0x1d4 #define KEY_FN_F4 0x1d5 #define KEY_FN_F5 0x1d6 #define KEY_FN_F6 0x1d7 #define KEY_FN_F7 0x1d8 #define KEY_FN_F8 0x1d9 #define KEY_FN_F9 0x1da #define KEY_FN_F10 0x1db #define KEY_FN_F11 0x1dc #define KEY_FN_F12 0x1dd #define KEY_FN_1 0x1de #define KEY_FN_2 0x1df #define KEY_FN_D 0x1e0 #define KEY_FN_E 0x1e1 #define KEY_FN_F 0x1e2 #define KEY_FN_S 0x1e3 #define KEY_FN_B 0x1e4 #define KEY_BRL_DOT1 0x1f1 #define KEY_BRL_DOT2 0x1f2 #define KEY_BRL_DOT3 0x1f3 #define KEY_BRL_DOT4 0x1f4 #define KEY_BRL_DOT5 0x1f5 #define KEY_BRL_DOT6 0x1f6 #define KEY_BRL_DOT7 0x1f7 #define KEY_BRL_DOT8 0x1f8 /* We avoid low common keys in module aliases so they don't get huge. */ #define KEY_MIN_INTERESTING KEY_MUTE #define KEY_MAX 0x1ff /* * Relative axes */ #define REL_X 0x00 #define REL_Y 0x01 #define REL_Z 0x02 #define REL_RX 0x03 #define REL_RY 0x04 #define REL_RZ 0x05 #define REL_HWHEEL 0x06 #define REL_DIAL 0x07 #define REL_WHEEL 0x08 #define REL_MISC 0x09 #define REL_MAX 0x0f /* * Absolute axes */ #define ABS_X 0x00 #define ABS_Y 0x01 #define ABS_Z 0x02 #define ABS_RX 0x03 #define ABS_RY 0x04 #define ABS_RZ 0x05 #define ABS_THROTTLE 0x06 #define ABS_RUDDER 0x07 #define ABS_WHEEL 0x08 #define ABS_GAS 0x09 #define ABS_BRAKE 0x0a #define ABS_HAT0X 0x10 #define ABS_HAT0Y 0x11 #define ABS_HAT1X 0x12 #define ABS_HAT1Y 0x13 #define ABS_HAT2X 0x14 #define ABS_HAT2Y 0x15 #define ABS_HAT3X 0x16 #define ABS_HAT3Y 0x17 #define ABS_PRESSURE 0x18 #define ABS_DISTANCE 0x19 #define ABS_TILT_X 0x1a #define ABS_TILT_Y 0x1b #define ABS_TOOL_WIDTH 0x1c #define ABS_VOLUME 0x20 #define ABS_MISC 0x28 #define ABS_MAX 0x3f /* * Switch events */ #define SW_LID 0x00 /* set = lid shut */ #define SW_TABLET_MODE 0x01 /* set = tablet mode */ #define SW_HEADPHONE_INSERT 0x02 /* set = inserted */ #define SW_MAX 0x0f /* * Misc events */ #define MSC_SERIAL 0x00 #define MSC_PULSELED 0x01 #define MSC_GESTURE 0x02 #define MSC_RAW 0x03 #define MSC_SCAN 0x04 #define MSC_MAX 0x07 /* * LEDs */ #define LED_NUML 0x00 #define LED_CAPSL 0x01 #define LED_SCROLLL 0x02 #define LED_COMPOSE 0x03 #define LED_KANA 0x04 #define LED_SLEEP 0x05 #define LED_SUSPEND 0x06 #define LED_MUTE 0x07 #define LED_MISC 0x08 #define LED_MAIL 0x09 #define LED_CHARGING 0x0a #define LED_MAX 0x0f /* * Autorepeat values */ #define REP_DELAY 0x00 #define REP_PERIOD 0x01 #define REP_MAX 0x01 /* * Sounds */ #define SND_CLICK 0x00 #define SND_BELL 0x01 #define SND_TONE 0x02 #define SND_MAX 0x07 /* * IDs. */ #define ID_BUS 0 #define ID_VENDOR 1 #define ID_PRODUCT 2 #define ID_VERSION 3 #define BUS_PCI 0x01 #define BUS_ISAPNP 0x02 #define BUS_USB 0x03 #define BUS_HIL 0x04 #define BUS_BLUETOOTH 0x05 #define BUS_VIRTUAL 0x06 #define BUS_ISA 0x10 #define BUS_I8042 0x11 #define BUS_XTKBD 0x12 #define BUS_RS232 0x13 #define BUS_GAMEPORT 0x14 #define BUS_PARPORT 0x15 #define BUS_AMIGA 0x16 #define BUS_ADB 0x17 #define BUS_I2C 0x18 #define BUS_HOST 0x19 #define BUS_GSC 0x1A /* * Values describing the status of a force-feedback effect */ #define FF_STATUS_STOPPED 0x00 #define FF_STATUS_PLAYING 0x01 #define FF_STATUS_MAX 0x01 /* * Structures used in ioctls to upload effects to a device * They are pieces of a bigger structure (called ff_effect) */ /* * All duration values are expressed in ms. Values above 32767 ms (0x7fff) * should not be used and have unspecified results. */ /** * struct ff_replay - defines scheduling of the force-feedback effect * @length: duration of the effect * @delay: delay before effect should start playing */ struct ff_replay { __u16 length; __u16 delay; }; /** * struct ff_trigger - defines what triggers the force-feedback effect * @button: number of the button triggering the effect * @interval: controls how soon the effect can be re-triggered */ struct ff_trigger { __u16 button; __u16 interval; }; /** * struct ff_envelope - generic force-feedback effect envelope * @attack_length: duration of the attack (ms) * @attack_level: level at the beginning of the attack * @fade_length: duration of fade (ms) * @fade_level: level at the end of fade * * The @attack_level and @fade_level are absolute values; when applying * envelope force-feedback core will convert to positive/negative * value based on polarity of the default level of the effect. * Valid range for the attack and fade levels is 0x0000 - 0x7fff */ struct ff_envelope { __u16 attack_length; __u16 attack_level; __u16 fade_length; __u16 fade_level; }; /** * struct ff_constant_effect - defines parameters of a constant force-feedback effect * @level: strength of the effect; may be negative * @envelope: envelope data */ struct ff_constant_effect { __s16 level; struct ff_envelope envelope; }; /** * struct ff_ramp_effect - defines parameters of a ramp force-feedback effect * @start_level: beginning strength of the effect; may be negative * @end_level: final strength of the effect; may be negative * @envelope: envelope data */ struct ff_ramp_effect { __s16 start_level; __s16 end_level; struct ff_envelope envelope; }; /** * struct ff_condition_effect - defines a spring or friction force-feedback effect * @right_saturation: maximum level when joystick moved all way to the right * @left_saturation: same for the left side * @right_coeff: controls how fast the force grows when the joystick moves * to the right * @left_coeff: same for the left side * @deadband: size of the dead zone, where no force is produced * @center: position of the dead zone */ struct ff_condition_effect { __u16 right_saturation; __u16 left_saturation; __s16 right_coeff; __s16 left_coeff; __u16 deadband; __s16 center; }; /** * struct ff_periodic_effect - defines parameters of a periodic force-feedback effect * @waveform: kind of the effect (wave) * @period: period of the wave (ms) * @magnitude: peak value * @offset: mean value of the wave (roughly) * @phase: 'horizontal' shift * @envelope: envelope data * @custom_len: number of samples (FF_CUSTOM only) * @custom_data: buffer of samples (FF_CUSTOM only) * * Known waveforms - FF_SQUARE, FF_TRIANGLE, FF_SINE, FF_SAW_UP, * FF_SAW_DOWN, FF_CUSTOM. The exact syntax FF_CUSTOM is undefined * for the time being as no driver supports it yet. * * Note: the data pointed by custom_data is copied by the driver. * You can therefore dispose of the memory after the upload/update. */ struct ff_periodic_effect { __u16 waveform; __u16 period; __s16 magnitude; __s16 offset; __u16 phase; struct ff_envelope envelope; __u32 custom_len; __s16 *custom_data; }; /** * struct ff_rumble_effect - defines parameters of a periodic force-feedback effect * @strong_magnitude: magnitude of the heavy motor * @weak_magnitude: magnitude of the light one * * Some rumble pads have two motors of different weight. Strong_magnitude * represents the magnitude of the vibration generated by the heavy one. */ struct ff_rumble_effect { __u16 strong_magnitude; __u16 weak_magnitude; }; /** * struct ff_effect - defines force feedback effect * @type: type of the effect (FF_CONSTANT, FF_PERIODIC, FF_RAMP, FF_SPRING, * FF_FRICTION, FF_DAMPER, FF_RUMBLE, FF_INERTIA, or FF_CUSTOM) * @id: an unique id assigned to an effect * @direction: direction of the effect * @trigger: trigger conditions (struct ff_trigger) * @replay: scheduling of the effect (struct ff_replay) * @u: effect-specific structure (one of ff_constant_effect, ff_ramp_effect, * ff_periodic_effect, ff_condition_effect, ff_rumble_effect) further * defining effect parameters * * This structure is sent through ioctl from the application to the driver. * To create a new effect aplication should set its @id to -1; the kernel * will return assigned @id which can later be used to update or delete * this effect. * * Direction of the effect is encoded as follows: * 0 deg -> 0x0000 (down) * 90 deg -> 0x4000 (left) * 180 deg -> 0x8000 (up) * 270 deg -> 0xC000 (right) */ struct ff_effect { __u16 type; __s16 id; __u16 direction; struct ff_trigger trigger; struct ff_replay replay; union { struct ff_constant_effect constant; struct ff_ramp_effect ramp; struct ff_periodic_effect periodic; struct ff_condition_effect condition[2]; /* One for each axis */ struct ff_rumble_effect rumble; } u; }; /* * Force feedback effect types */ #define FF_RUMBLE 0x50 #define FF_PERIODIC 0x51 #define FF_CONSTANT 0x52 #define FF_SPRING 0x53 #define FF_FRICTION 0x54 #define FF_DAMPER 0x55 #define FF_INERTIA 0x56 #define FF_RAMP 0x57 #define FF_EFFECT_MIN FF_RUMBLE #define FF_EFFECT_MAX FF_RAMP /* * Force feedback periodic effect types */ #define FF_SQUARE 0x58 #define FF_TRIANGLE 0x59 #define FF_SINE 0x5a #define FF_SAW_UP 0x5b #define FF_SAW_DOWN 0x5c #define FF_CUSTOM 0x5d #define FF_WAVEFORM_MIN FF_SQUARE #define FF_WAVEFORM_MAX FF_CUSTOM /* * Set ff device properties */ #define FF_GAIN 0x60 #define FF_AUTOCENTER 0x61 #define FF_MAX 0x7f #ifdef __KERNEL__ /* * In-kernel definitions. */ #include <linux/device.h> #include <linux/fs.h> #include <linux/timer.h> #include <linux/mod_devicetable.h> #define NBITS(x) (((x)/BITS_PER_LONG)+1) #define BIT(x) (1UL<<((x)%BITS_PER_LONG)) #define LONG(x) ((x)/BITS_PER_LONG) #define INPUT_KEYCODE(dev, scancode) ((dev->keycodesize == 1) ? ((u8*)dev->keycode)[scancode] : \ ((dev->keycodesize == 2) ? ((u16*)dev->keycode)[scancode] : (((u32*)dev->keycode)[scancode]))) #define SET_INPUT_KEYCODE(dev, scancode, val) \ ({ unsigned __old; \ switch (dev->keycodesize) { \ case 1: { \ u8 *k = (u8 *)dev->keycode; \ __old = k[scancode]; \ k[scancode] = val; \ break; \ } \ case 2: { \ u16 *k = (u16 *)dev->keycode; \ __old = k[scancode]; \ k[scancode] = val; \ break; \ } \ default: { \ u32 *k = (u32 *)dev->keycode; \ __old = k[scancode]; \ k[scancode] = val; \ break; \ } \ } \ __old; }) struct input_dev { void *private; const char *name; const char *phys; const char *uniq; struct input_id id; unsigned long evbit[NBITS(EV_MAX)]; unsigned long keybit[NBITS(KEY_MAX)]; unsigned long relbit[NBITS(REL_MAX)]; unsigned long absbit[NBITS(ABS_MAX)]; unsigned long mscbit[NBITS(MSC_MAX)]; unsigned long ledbit[NBITS(LED_MAX)]; unsigned long sndbit[NBITS(SND_MAX)]; unsigned long ffbit[NBITS(FF_MAX)]; unsigned long swbit[NBITS(SW_MAX)]; unsigned int keycodemax; unsigned int keycodesize; void *keycode; struct ff_device *ff; unsigned int repeat_key; struct timer_list timer; int state; int sync; int abs[ABS_MAX + 1]; int rep[REP_MAX + 1]; unsigned long key[NBITS(KEY_MAX)]; unsigned long led[NBITS(LED_MAX)]; unsigned long snd[NBITS(SND_MAX)]; unsigned long sw[NBITS(SW_MAX)]; int absmax[ABS_MAX + 1]; int absmin[ABS_MAX + 1]; int absfuzz[ABS_MAX + 1]; int absflat[ABS_MAX + 1]; int (*open)(struct input_dev *dev); void (*close)(struct input_dev *dev); int (*flush)(struct input_dev *dev, struct file *file); int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value); struct input_handle *grab; struct mutex mutex; /* serializes open and close operations */ unsigned int users; struct class_device cdev; struct list_head h_list; struct list_head node; }; #define to_input_dev(d) container_of(d, struct input_dev, cdev) /* * Verify that we are in sync with input_device_id mod_devicetable.h #defines */ #if EV_MAX != INPUT_DEVICE_ID_EV_MAX #error "EV_MAX and INPUT_DEVICE_ID_EV_MAX do not match" #endif #if KEY_MAX != INPUT_DEVICE_ID_KEY_MAX #error "KEY_MAX and INPUT_DEVICE_ID_KEY_MAX do not match" #endif #if REL_MAX != INPUT_DEVICE_ID_REL_MAX #error "REL_MAX and INPUT_DEVICE_ID_REL_MAX do not match" #endif #if ABS_MAX != INPUT_DEVICE_ID_ABS_MAX #error "ABS_MAX and INPUT_DEVICE_ID_ABS_MAX do not match" #endif #if MSC_MAX != INPUT_DEVICE_ID_MSC_MAX #error "MSC_MAX and INPUT_DEVICE_ID_MSC_MAX do not match" #endif #if LED_MAX != INPUT_DEVICE_ID_LED_MAX #error "LED_MAX and INPUT_DEVICE_ID_LED_MAX do not match" #endif #if SND_MAX != INPUT_DEVICE_ID_SND_MAX #error "SND_MAX and INPUT_DEVICE_ID_SND_MAX do not match" #endif #if FF_MAX != INPUT_DEVICE_ID_FF_MAX #error "FF_MAX and INPUT_DEVICE_ID_FF_MAX do not match" #endif #if SW_MAX != INPUT_DEVICE_ID_SW_MAX #error "SW_MAX and INPUT_DEVICE_ID_SW_MAX do not match" #endif #define INPUT_DEVICE_ID_MATCH_DEVICE \ (INPUT_DEVICE_ID_MATCH_BUS | INPUT_DEVICE_ID_MATCH_VENDOR | INPUT_DEVICE_ID_MATCH_PRODUCT) #define INPUT_DEVICE_ID_MATCH_DEVICE_AND_VERSION \ (INPUT_DEVICE_ID_MATCH_DEVICE | INPUT_DEVICE_ID_MATCH_VERSION) struct input_handle; /** * struct input_handler - implements one of interfaces for input devices * @private: driver-specific data * @event: event handler * @connect: called when attaching a handler to an input device * @disconnect: disconnects a handler from input device * @start: starts handler for given handle. This function is called by * input core right after connect() method and also when a process * that "grabbed" a device releases it * @fops: file operations this driver implements * @minor: beginning of range of 32 minors for devices this driver * can provide * @name: name of the handler, to be shown in /proc/bus/input/handlers * @id_table: pointer to a table of input_device_ids this driver can * handle * @blacklist: prointer to a table of input_device_ids this driver should * ignore even if they match @id_table * @h_list: list of input handles associated with the handler * @node: for placing the driver onto input_handler_list */ struct input_handler { void *private; void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value); struct input_handle* (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id); void (*disconnect)(struct input_handle *handle); void (*start)(struct input_handle *handle); const struct file_operations *fops; int minor; const char *name; const struct input_device_id *id_table; const struct input_device_id *blacklist; struct list_head h_list; struct list_head node; }; struct input_handle { void *private; int open; const char *name; struct input_dev *dev; struct input_handler *handler; struct list_head d_node; struct list_head h_node; }; #define to_dev(n) container_of(n,struct input_dev,node) #define to_handler(n) container_of(n,struct input_handler,node); #define to_handle(n) container_of(n,struct input_handle,d_node) #define to_handle_h(n) container_of(n,struct input_handle,h_node) struct input_dev *input_allocate_device(void); void input_free_device(struct input_dev *dev); static inline struct input_dev *input_get_device(struct input_dev *dev) { return to_input_dev(class_device_get(&dev->cdev)); } static inline void input_put_device(struct input_dev *dev) { class_device_put(&dev->cdev); } int input_register_device(struct input_dev *); void input_unregister_device(struct input_dev *); int input_register_handler(struct input_handler *); void input_unregister_handler(struct input_handler *); int input_grab_device(struct input_handle *); void input_release_device(struct input_handle *); int input_open_device(struct input_handle *); void input_close_device(struct input_handle *); int input_flush_device(struct input_handle* handle, struct file* file); void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value); void input_inject_event(struct input_handle *handle, unsigned int type, unsigned int code, int value); static inline void input_report_key(struct input_dev *dev, unsigned int code, int value) { input_event(dev, EV_KEY, code, !!value); } static inline void input_report_rel(struct input_dev *dev, unsigned int code, int value) { input_event(dev, EV_REL, code, value); } static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value) { input_event(dev, EV_ABS, code, value); } static inline void input_report_ff_status(struct input_dev *dev, unsigned int code, int value) { input_event(dev, EV_FF_STATUS, code, value); } static inline void input_report_switch(struct input_dev *dev, unsigned int code, int value) { input_event(dev, EV_SW, code, !!value); } static inline void input_sync(struct input_dev *dev) { input_event(dev, EV_SYN, SYN_REPORT, 0); } static inline void input_set_abs_params(struct input_dev *dev, int axis, int min, int max, int fuzz, int flat) { dev->absmin[axis] = min; dev->absmax[axis] = max; dev->absfuzz[axis] = fuzz; dev->absflat[axis] = flat; dev->absbit[LONG(axis)] |= BIT(axis); } extern struct class input_class; /** * struct ff_device - force-feedback part of an input device * @upload: Called to upload an new effect into device * @erase: Called to erase an effect from device * @playback: Called to request device to start playing specified effect * @set_gain: Called to set specified gain * @set_autocenter: Called to auto-center device * @destroy: called by input core when parent input device is being * destroyed * @private: driver-specific data, will be freed automatically * @ffbit: bitmap of force feedback capabilities truly supported by * device (not emulated like ones in input_dev->ffbit) * @mutex: mutex for serializing access to the device * @max_effects: maximum number of effects supported by device * @effects: pointer to an array of effects currently loaded into device * @effect_owners: array of effect owners; when file handle owning * an effect gets closed the effcet is automatically erased * * Every force-feedback device must implement upload() and playback() * methods; erase() is optional. set_gain() and set_autocenter() need * only be implemented if driver sets up FF_GAIN and FF_AUTOCENTER * bits. */ struct ff_device { int (*upload)(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old); int (*erase)(struct input_dev *dev, int effect_id); int (*playback)(struct input_dev *dev, int effect_id, int value); void (*set_gain)(struct input_dev *dev, u16 gain); void (*set_autocenter)(struct input_dev *dev, u16 magnitude); void (*destroy)(struct ff_device *); void *private; unsigned long ffbit[NBITS(FF_MAX)]; struct mutex mutex; int max_effects; struct ff_effect *effects; struct file *effect_owners[]; }; int input_ff_create(struct input_dev *dev, int max_effects); void input_ff_destroy(struct input_dev *dev); int input_ff_event(struct input_dev *dev, unsigned int type, unsigned int code, int value); int input_ff_upload(struct input_dev *dev, struct ff_effect *effect, struct file *file); int input_ff_erase(struct input_dev *dev, int effect_id, struct file *file); int input_ff_create_memless(struct input_dev *dev, void *data, int (*play_effect)(struct input_dev *, void *, struct ff_effect *)); #endif #endif
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?470BB0B6.5000102>