diff --git a/etc/mtree/BSD.include.dist b/etc/mtree/BSD.include.dist index a9baa7e..795190e 100644 --- a/etc/mtree/BSD.include.dist +++ b/etc/mtree/BSD.include.dist @@ -108,6 +108,8 @@ .. ciss .. + evdev + .. filemon .. firewire diff --git a/include/Makefile b/include/Makefile index d8ed1a2..71f4321 100644 --- a/include/Makefile +++ b/include/Makefile @@ -154,7 +154,7 @@ copies: done; \ fi .endfor -.for i in ${LDIRS} ${LSUBDIRS:Ndev/agp:Ndev/acpica:Ndev/bktr:Ndev/nand:Ndev/pci} ${LSUBSUBDIRS} +.for i in ${LDIRS} ${LSUBDIRS:Ndev/agp:Ndev/acpica:Ndev/bktr:Ndev/evdev:Ndev/nand:Ndev/pci} ${LSUBSUBDIRS} cd ${.CURDIR}/../sys; \ ${INSTALL} -C ${TAG_ARGS} -o ${BINOWN} -g ${BINGRP} -m 444 $i/*.h \ ${DESTDIR}${INCLUDEDIR}/$i @@ -177,6 +177,11 @@ copies: ${INSTALL} -C ${TAG_ARGS} -o ${BINOWN} -g ${BINGRP} -m 444 nand_dev.h \ ${DESTDIR}${INCLUDEDIR}/dev/nand .endif + cd ${.CURDIR}/../sys/dev/evdev; \ + ${INSTALL} -C -o ${BINOWN} -g ${BINGRP} -m 444 input.h \ + ${DESTDIR}${INCLUDEDIR}/dev/evdev; \ + ${INSTALL} -C -o ${BINOWN} -g ${BINGRP} -m 444 uinput.h \ + ${DESTDIR}${INCLUDEDIR}/dev/evdev cd ${.CURDIR}/../sys/dev/pci; \ ${INSTALL} -C ${TAG_ARGS} -o ${BINOWN} -g ${BINGRP} -m 444 pcireg.h \ ${DESTDIR}${INCLUDEDIR}/dev/pci @@ -238,7 +243,7 @@ symlinks: ${INSTALL_SYMLINK} ${TAG_ARGS} ../../../sys/$i/$$h ${DESTDIR}${INCLUDEDIR}/$i; \ done .endfor -.for i in ${LSUBDIRS:Ndev/agp:Ndev/acpica:Ndev/bktr:Ndev/nand:Ndev/pci} +.for i in ${LSUBDIRS:Ndev/agp:Ndev/acpica:Ndev/bktr:Ndev/evdev:Ndev/nand:Ndev/pci} cd ${.CURDIR}/../sys/$i; \ for h in *.h; do \ ${INSTALL_SYMLINK} ${TAG_ARGS} ../../../../sys/$i/$$h ${DESTDIR}${INCLUDEDIR}/$i; \ @@ -266,6 +271,11 @@ symlinks: ${DESTDIR}${INCLUDEDIR}/dev/nand; \ done .endif + cd ${.CURDIR}/../sys/dev/evdev; \ + for h in input.h uinput.h; do \ + ln -fs ../../../../sys/dev/evdev/$$h \ + ${DESTDIR}${INCLUDEDIR}/dev/evdev; \ + done cd ${.CURDIR}/../sys/dev/pci; \ for h in pcireg.h; do \ ${INSTALL_SYMLINK} ${TAG_ARGS} ../../../../sys/dev/pci/$$h \ diff --git a/sys/conf/files b/sys/conf/files index 0968026..bda2acb 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -1463,6 +1463,10 @@ dev/etherswitch/ip17x/ip17x_vlans.c optional ip17x dev/etherswitch/miiproxy.c optional miiproxy dev/etherswitch/rtl8366/rtl8366rb.c optional rtl8366rb dev/etherswitch/ukswitch/ukswitch.c optional ukswitch +dev/evdev/evdev.c optional evdev +dev/evdev/cdev.c optional evdev +dev/evdev/evdev_utils.c optional evdev +dev/evdev/uinput.c optional evdev dev/ex/if_ex.c optional ex dev/ex/if_ex_isa.c optional ex isa dev/ex/if_ex_pccard.c optional ex pccard diff --git a/sys/conf/options b/sys/conf/options index 7735f37..5545f06 100644 --- a/sys/conf/options +++ b/sys/conf/options @@ -980,5 +980,8 @@ RANDOM_ENABLE_UMA opt_global.h # Intel em(4) driver EM_MULTIQUEUE opt_em.h +# evdev protocol support +EVDEV opt_evdev.h + # BHND(4) driver BHND_LOGLEVEL opt_global.h diff --git a/sys/dev/evdev/cdev.c b/sys/dev/evdev/cdev.c new file mode 100644 index 0000000..f11e967 --- /dev/null +++ b/sys/dev/evdev/cdev.c @@ -0,0 +1,683 @@ +/*- + * Copyright (c) 2014 Jakub Wojciech Klama + * All rights reserved. + * + * 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. + * + * $FreeBSD$ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#undef DEBUG +#ifdef DEBUG +#define debugf(fmt, args...) printf("evdev: " fmt "\n", ##args); +#else +#define debugf(fmt, args...) +#endif + +static int evdev_open(struct cdev *, int, int, struct thread *); +static int evdev_close(struct cdev *, int, int, struct thread *); +static int evdev_read(struct cdev *, struct uio *, int); +static int evdev_write(struct cdev *, struct uio *, int); +static int evdev_ioctl(struct cdev *, u_long, caddr_t, int, struct thread *); +static int evdev_poll(struct cdev *, int, struct thread *); +static int evdev_kqfilter(struct cdev *, struct knote *); +static int evdev_kqread(struct knote *kn, long hint); +static void evdev_kqdetach(struct knote *kn); +static void evdev_dtor(void *); + +static void evdev_notify_event(struct evdev_client *, void *); +static int evdev_ioctl_eviocgbit(struct evdev_dev *, int, int, caddr_t); + +static struct cdevsw evdev_cdevsw = { + .d_version = D_VERSION, + .d_open = evdev_open, + .d_close = evdev_close, + .d_read = evdev_read, + .d_write = evdev_write, + .d_ioctl = evdev_ioctl, + .d_poll = evdev_poll, + .d_kqfilter = evdev_kqfilter, + .d_name = "evdev", + .d_flags = D_TRACKCLOSE +}; + +static struct filterops evdev_cdev_filterops = { + .f_isfd = 1, + .f_attach = NULL, + .f_detach = evdev_kqdetach, + .f_event = evdev_kqread, +}; + +struct evdev_cdev_softc +{ + struct evdev_dev * ecs_evdev; + int ecs_open_count; + + LIST_ENTRY(evdev_cdev_softc) ecs_link; +}; + +struct evdev_cdev_state +{ + struct mtx ecs_mtx; + struct evdev_client * ecs_client; + struct selinfo ecs_selp; + struct sigio * ecs_sigio; + bool ecs_async; + bool ecs_revoked; + bool ecs_blocked; + bool ecs_selected; +}; + +static int evdev_cdev_count = 0; + +static int +evdev_open(struct cdev *dev, int oflags, int devtype, struct thread *td) +{ + struct evdev_cdev_softc *sc = dev->si_drv1; + struct evdev_dev *evdev = sc->ecs_evdev; + struct evdev_cdev_state *state; + int ret; + + if (!(evdev->ev_flags & EV_RUNNING)) + return (ENODEV); + + state = malloc(sizeof(struct evdev_cdev_state), M_EVDEV, M_WAITOK | M_ZERO); + + ret = evdev_register_client(evdev, &state->ecs_client); + if (ret != 0) { + free(state, M_EVDEV); + debugf("cdev: cannot register evdev client"); + return (ret); + } + + state->ecs_client->ec_ev_notify = &evdev_notify_event; + state->ecs_client->ec_ev_arg = state; + + knlist_init_mtx(&state->ecs_selp.si_note, + &state->ecs_client->ec_buffer_mtx); + + sc->ecs_open_count++; + devfs_set_cdevpriv(state, evdev_dtor); + return (0); +} + +static int +evdev_close(struct cdev *dev, int fflag, int devtype, struct thread *td) +{ + struct evdev_cdev_softc *sc = dev->si_drv1; + + sc->ecs_open_count--; + return (0); +} + +static void +evdev_dtor(void *data) +{ + struct evdev_cdev_state *state = (struct evdev_cdev_state *)data; + + knlist_clear(&state->ecs_selp.si_note, 0); + seldrain(&state->ecs_selp); + knlist_destroy(&state->ecs_selp.si_note); + funsetown(&state->ecs_sigio); + evdev_dispose_client(state->ecs_client); + free(data, M_EVDEV); +} + +static int +evdev_read(struct cdev *dev, struct uio *uio, int ioflag) +{ + struct evdev_cdev_softc *sc = dev->si_drv1; + struct evdev_dev *evdev = sc->ecs_evdev; + struct evdev_cdev_state *state; + struct evdev_client *client; + struct input_event *event; + int ret = 0; + int remaining; + + debugf("cdev: read %zd bytes by thread %d", uio->uio_resid, + uio->uio_td->td_tid); + + ret = devfs_get_cdevpriv((void **)&state); + if (ret != 0) + return (ret); + + if (state->ecs_revoked || !(evdev->ev_flags & EV_RUNNING)) + return (ENODEV); + + client = state->ecs_client; + + /* Zero-sized reads are allowed for error checking */ + if (uio->uio_resid != 0 && uio->uio_resid < sizeof(struct input_event)) + return (EINVAL); + + remaining = uio->uio_resid / sizeof(struct input_event); + + EVDEV_CLIENT_LOCKQ(client); + + if (EVDEV_CLIENT_EMPTYQ(client)) { + if (ioflag & O_NONBLOCK) + ret = EWOULDBLOCK; + else { + if (remaining != 0) { + state->ecs_blocked = true; + ret = mtx_sleep(client, &client->ec_buffer_mtx, + PCATCH, "evread", 0); + } + } + } + + client->ec_read = true; + while (ret == 0 && !EVDEV_CLIENT_EMPTYQ(client) && remaining > 0) { + event = &client->ec_buffer[client->ec_buffer_head]; + client->ec_buffer_head = (client->ec_buffer_head + 1) % client->ec_buffer_size; + remaining--; + + /* If queue dropping was postponed, say "We got some space" */ + if (client->ec_overflown) + wakeup(client); + + EVDEV_CLIENT_UNLOCKQ(client); + ret = uiomove(event, sizeof(struct input_event), uio); + EVDEV_CLIENT_LOCKQ(client); + } + + client->ec_read = false; + /* If queue dropping was postponed, allow it */ + if (client->ec_overflown) + wakeup(client); + EVDEV_CLIENT_UNLOCKQ(client); + + return (ret); +} + +static int +evdev_write(struct cdev *dev, struct uio *uio, int ioflag) +{ + struct evdev_cdev_softc *sc = dev->si_drv1; + struct evdev_dev *evdev = sc->ecs_evdev; + struct evdev_cdev_state *state; + int ret = 0; + + debugf("cdev: write %zd bytes by thread %d", uio->uio_resid, + uio->uio_td->td_tid); + + ret = devfs_get_cdevpriv((void **)&state); + if (ret != 0) + return (ret); + + if (state->ecs_revoked || !(evdev->ev_flags & EV_RUNNING)) + return (ENODEV); + + if (uio->uio_resid % sizeof(struct input_event) != 0) { + debugf("write size not multiple of struct input_event size"); + return (EINVAL); + } + + return (0); +} + +static int +evdev_poll(struct cdev *dev, int events, struct thread *td) +{ + struct evdev_cdev_softc *sc = dev->si_drv1; + struct evdev_dev *evdev = sc->ecs_evdev; + struct evdev_client *client; + struct evdev_cdev_state *state; + int ret; + int revents = 0; + + debugf("cdev: poll by thread %d", td->td_tid); + + ret = devfs_get_cdevpriv((void **)&state); + if (ret != 0) + return (POLLNVAL); + + if (state->ecs_revoked || !(evdev->ev_flags & EV_RUNNING)) + return (POLLNVAL); + + client = state->ecs_client; + + if (events & (POLLIN | POLLRDNORM)) { + EVDEV_CLIENT_LOCKQ(client); + if (!EVDEV_CLIENT_EMPTYQ(client)) + revents = events & (POLLIN | POLLRDNORM); + else { + state->ecs_selected = true; + selrecord(td, &state->ecs_selp); + } + EVDEV_CLIENT_UNLOCKQ(client); + } + + return (revents); +} + +static int +evdev_kqfilter(struct cdev *dev, struct knote *kn) +{ + struct evdev_cdev_softc *sc = dev->si_drv1; + struct evdev_dev *evdev = sc->ecs_evdev; + struct evdev_cdev_state *state; + int ret; + + ret = devfs_get_cdevpriv((void **)&state); + if (ret != 0) + return (ret); + + if (state->ecs_revoked || !(evdev->ev_flags & EV_RUNNING)) + return (ENODEV); + + switch(kn->kn_filter) { + case EVFILT_READ: + kn->kn_fop = &evdev_cdev_filterops; + break; + default: + return(EINVAL); + } + kn->kn_hook = (caddr_t)state; + + knlist_add(&state->ecs_selp.si_note, kn, 0); + return (0); +} + +static int +evdev_kqread(struct knote *kn, long hint) +{ + struct evdev_client *client; + struct evdev_cdev_state *state; + int ret; + + state = (struct evdev_cdev_state *)kn->kn_hook; + client = state->ecs_client; + + EVDEV_CLIENT_LOCKQ(client); + ret = !EVDEV_CLIENT_EMPTYQ(client); + EVDEV_CLIENT_UNLOCKQ(client); + return (ret); +} + +static void +evdev_kqdetach(struct knote *kn) +{ + struct evdev_cdev_state *state; + + state = (struct evdev_cdev_state *)kn->kn_hook; + knlist_remove(&state->ecs_selp.si_note, kn, 0); +} + +static int +evdev_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, + struct thread *td) +{ + struct evdev_cdev_softc *sc = dev->si_drv1; + struct evdev_dev *evdev = sc->ecs_evdev; + struct evdev_cdev_state *state; + struct input_keymap_entry *ke; + int rep_params[2]; + int ret, len, limit, type_num; + + ret = devfs_get_cdevpriv((void **)&state); + if (ret != 0) + return (ret); + + if (state->ecs_revoked || !(evdev->ev_flags & EV_RUNNING)) + return (ENODEV); + + /* file I/O ioctl handling */ + switch (cmd) { + case FIOSETOWN: + return (fsetown(*(int *)data, &state->ecs_sigio)); + + case FIOGETOWN: + *(int *)data = fgetown(&state->ecs_sigio); + return (0); + + case FIONBIO: + return (0); + + case FIOASYNC: + if (*(int *)data) + state->ecs_async = true; + else + state->ecs_async = false; + + return (0); + } + + len = IOCPARM_LEN(cmd); + debugf("cdev: ioctl called: cmd=0x%08lx, data=%p", cmd, data); + + /* evdev fixed-length ioctls handling */ + switch (cmd) { + case EVIOCGVERSION: + *(int *)data = EV_VERSION; + return (0); + + case EVIOCGID: + debugf("cdev: EVIOCGID: bus=%d vendor=0x%04x product=0x%04x", + evdev->ev_id.bustype, evdev->ev_id.vendor, + evdev->ev_id.product); + memcpy(data, &evdev->ev_id, sizeof(struct input_id)); + return (0); + + case EVIOCGREP: + if ((evdev->ev_flags & EV_REPEAT_MASK) == EV_NO_REPEAT) + return (ENOTSUP); + + rep_params[0] = evdev->ev_rep[REP_DELAY]; + rep_params[1] = evdev->ev_rep[REP_PERIOD]; + memcpy(data, rep_params, sizeof(rep_params)); + return (0); + + case EVIOCSREP: + if ((evdev->ev_flags & EV_REPEAT_MASK) == EV_NO_REPEAT) + return (ENOTSUP); + + memcpy(rep_params, data, sizeof(rep_params)); + evdev->ev_rep[REP_DELAY] = rep_params[0]; + evdev->ev_rep[REP_PERIOD] = rep_params[1]; + + if ((evdev->ev_flags & EV_REPEAT_MASK) == EV_DRIVER_REPEAT) { + evdev_inject_event(evdev, EV_REP, REP_DELAY, rep_params[0]); + evdev_inject_event(evdev, EV_REP, REP_PERIOD, rep_params[1]); + } + return (0); + + case EVIOCGKEYCODE: + /* Fake unsupported ioctl */ + return (0); + + case EVIOCGKEYCODE_V2: + if (evdev->ev_methods->ev_get_keycode == NULL) + return (ENOTSUP); + + ke = (struct input_keymap_entry *)data; + evdev->ev_methods->ev_get_keycode(evdev, evdev->ev_softc, ke); + return (0); + + case EVIOCSKEYCODE: + /* Fake unsupported ioctl */ + return (0); + + case EVIOCSKEYCODE_V2: + if (evdev->ev_methods->ev_set_keycode == NULL) + return (ENOTSUP); + + ke = (struct input_keymap_entry *)data; + evdev->ev_methods->ev_set_keycode(evdev, evdev->ev_softc, ke); + return (0); + + case EVIOCGABS(0) ... EVIOCGABS(ABS_MAX): + memcpy(data, &evdev->ev_absinfo[cmd - EVIOCGABS(0)], + sizeof(struct input_absinfo)); + return (0); + + case EVIOCSABS(0) ... EVIOCSABS(ABS_MAX): + EVDEV_LOCK(evdev); + memcpy(&evdev->ev_absinfo[cmd - EVIOCSABS(0)], data, + sizeof(struct input_absinfo)); + EVDEV_UNLOCK(evdev); + return (0); + + case EVIOCSFF: + case EVIOCRMFF: + case EVIOCGEFFECTS: + /* Fake unsupported ioctls */ + return (0); + + case EVIOCGRAB: + if (*(int *)data) + return (evdev_grab_client(state->ecs_client)); + else + return (evdev_release_client(state->ecs_client)); + + case EVIOCREVOKE: + if (*(int *)data != 0) + return (EINVAL); + + state->ecs_revoked = true; + return (0); + + case EVIOCSCLOCKID: + switch (*(int *)data) { + case CLOCK_REALTIME: + state->ecs_client->ec_clock_id = EV_CLOCK_REALTIME; + return (0); + case CLOCK_MONOTONIC: + state->ecs_client->ec_clock_id = EV_CLOCK_MONOTONIC; + return (0); + default: + return (EINVAL); + } + } + + /* evdev variable-length ioctls handling */ + switch (IOCBASECMD(cmd)) { + case EVIOCGNAME(0): + strlcpy(data, evdev->ev_name, len); + return (0); + + case EVIOCGPHYS(0): + if (evdev->ev_dev == NULL && evdev->ev_shortname[0] == 0) + return (ENOENT); + + strlcpy(data, evdev->ev_shortname, len); + return (0); + + case EVIOCGUNIQ(0): + if (evdev->ev_dev == NULL && evdev->ev_serial[0] == 0) + return (ENOENT); + + strlcpy(data, evdev->ev_serial, len); + return (0); + + case EVIOCGPROP(0): + limit = MIN(len, howmany(INPUT_PROP_CNT, 8)); + memcpy(data, evdev->ev_prop_flags, limit); + return (0); + + case EVIOCGMTSLOTS(0): + if (len < sizeof(uint32_t)) + return (EINVAL); + uint32_t code = *(uint32_t *)data; + if (!ABS_IS_MT(code)) + return (EINVAL); + + struct input_mt_request_layout mtrl = { .code = code }; + for (int i = 0; i < MAX_MT_SLOTS; i++) + mtrl.values[i] = + evdev->ev_mt_states[i][ABS_MT_INDEX(code)]; + limit = MIN(len, sizeof(mtrl)); + memcpy(data, &mtrl, limit); + return (0); + + case EVIOCGKEY(0): + evdev_client_filter_queue(state->ecs_client, EV_KEY); + limit = MIN(len, howmany(KEY_CNT, 8)); + memcpy(data, evdev->ev_key_states, limit); + return (0); + + case EVIOCGLED(0): + evdev_client_filter_queue(state->ecs_client, EV_LED); + limit = MIN(len, howmany(LED_CNT, 8)); + memcpy(data, evdev->ev_led_states, limit); + return (0); + + case EVIOCGSND(0): + evdev_client_filter_queue(state->ecs_client, EV_SND); + limit = MIN(len, howmany(SND_CNT, 8)); + memcpy(data, evdev->ev_snd_states, limit); + return (0); + + case EVIOCGSW(0): + evdev_client_filter_queue(state->ecs_client, EV_SW); + limit = MIN(len, howmany(SW_CNT, 8)); + memcpy(data, evdev->ev_sw_states, limit); + return (0); + + case EVIOCGBIT(0, 0) ... EVIOCGBIT(EV_MAX, 0): + type_num = IOCBASECMD(cmd) - EVIOCGBIT(0, 0); + debugf("cdev: EVIOCGBIT(%d): data=%p, len=%d", type_num, data, len); + return (evdev_ioctl_eviocgbit(evdev, type_num, len, data)); + } + + return (EINVAL); +} + +static int +evdev_ioctl_eviocgbit(struct evdev_dev *evdev, int type, int len, caddr_t data) +{ + unsigned long *bitmap; + int limit; + + switch (type) { + case 0: + bitmap = evdev->ev_type_flags; + limit = EV_CNT; + break; + case EV_KEY: + bitmap = evdev->ev_key_flags; + limit = KEY_CNT; + break; + case EV_REL: + bitmap = evdev->ev_rel_flags; + limit = REL_CNT; + break; + case EV_ABS: + bitmap = evdev->ev_abs_flags; + limit = ABS_CNT; + break; + case EV_MSC: + bitmap = evdev->ev_msc_flags; + limit = MSC_CNT; + break; + case EV_LED: + bitmap = evdev->ev_led_flags; + limit = LED_CNT; + break; + case EV_SND: + bitmap = evdev->ev_snd_flags; + limit = SND_CNT; + break; + case EV_SW: + bitmap = evdev->ev_sw_flags; + limit = SW_CNT; + break; + case EV_FF: + /* + * We don't support EV_FF now, so let's + * just fake it returning only zeros. + */ + bzero(data, len); + return (0); + default: + return (ENOTTY); + } + + /* + * Clear ioctl data buffer in case it's bigger than + * bitmap size + */ + bzero(data, len); + + limit = nlongs(limit) * sizeof(unsigned long); + len = MIN(limit, len); + memcpy(data, bitmap, len); + return (0); +} + +static void +evdev_notify_event(struct evdev_client *client, void *data) +{ + struct evdev_cdev_state *state = (struct evdev_cdev_state *)data; + + if (state->ecs_blocked) { + state->ecs_blocked = false; + wakeup(client); + } + if (state->ecs_selected) { + state->ecs_selected = false; + selwakeup(&state->ecs_selp); + } + KNOTE_LOCKED(&state->ecs_selp.si_note, 0); + + if (state->ecs_async && state->ecs_sigio != NULL) + pgsigio(&state->ecs_sigio, SIGIO, 0); +} + +int +evdev_cdev_create(struct evdev_dev *evdev) +{ + struct evdev_cdev_softc *sc; + struct make_dev_args mda; + int ret, unit = 0; + + sc = malloc(sizeof(struct evdev_cdev_softc), M_EVDEV, + M_WAITOK | M_ZERO); + sc->ecs_evdev = evdev; + + make_dev_args_init(&mda); + mda.mda_flags = MAKEDEV_WAITOK | MAKEDEV_CHECKNAME; + mda.mda_devsw = &evdev_cdevsw; + mda.mda_uid = UID_ROOT; + mda.mda_gid = GID_WHEEL; + mda.mda_mode = 0600; + mda.mda_si_drv1 = sc; + + /* Try to coexist with cuse-backed input/event devices */ + while ((ret = make_dev_s(&mda, &evdev->ev_cdev, "input/event%d", unit)) + == EEXIST) + unit++; + if (ret != 0) { + free(sc, M_EVDEV); + return (ret); + } + + evdev_cdev_count++; + evdev->ev_unit = unit; + return (0); +} + +int +evdev_cdev_destroy(struct evdev_dev *evdev) +{ + + destroy_dev(evdev->ev_cdev); + evdev_cdev_count--; + return (0); +} diff --git a/sys/dev/evdev/evdev.c b/sys/dev/evdev/evdev.c new file mode 100644 index 0000000..b0da42c --- /dev/null +++ b/sys/dev/evdev/evdev.c @@ -0,0 +1,983 @@ +/*- + * Copyright (c) 2014 Jakub Wojciech Klama + * All rights reserved. + * + * 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. + * + * $FreeBSD$ + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#include +#include + +#ifdef DEBUG +#define debugf(fmt, args...) printf("evdev: " fmt "\n", ##args) +#else +#define debugf(fmt, args...) +#endif + +#define DEF_RING_REPORTS 8 + +MALLOC_DEFINE(M_EVDEV, "evdev", "evdev memory"); + +static inline void set_bit(unsigned long *, int); +static inline void clr_bit(unsigned long *, int); +static inline void change_bit(unsigned long *, int, int); +static inline int get_bit(unsigned long *, int); +static void evdev_assign_id(struct evdev_dev *); +#if 0 +static void evdev_start_repeat(struct evdev_dev *, int32_t); +static void evdev_stop_repeat(struct evdev_dev *); +#endif +static int evdev_check_event(struct evdev_dev *, uint16_t, uint16_t, int32_t); +static void evdev_client_push(struct evdev_client *, uint16_t, uint16_t, + int32_t); + +static inline void +set_bit(unsigned long *array, int bit) +{ + array[bit / LONG_WIDTH] |= (1LL << (bit % LONG_WIDTH)); +} + +static inline void +clr_bit(unsigned long *array, int bit) +{ + array[bit / LONG_WIDTH] &= ~(1LL << (bit % LONG_WIDTH)); +} + +static inline void +change_bit(unsigned long *array, int bit, int value) +{ + if (value) + set_bit(array, bit); + else + clr_bit(array, bit); +} + +static inline int +get_bit(unsigned long *array, int bit) +{ + return ((array[bit / LONG_WIDTH] & (1LL << (bit % LONG_WIDTH))) > 0); +} + +struct evdev_dev * +evdev_alloc(void) +{ + + return malloc(sizeof(struct evdev_dev), M_EVDEV, M_WAITOK | M_ZERO); +} + +void +evdev_free(struct evdev_dev *evdev) +{ + + free(evdev, M_EVDEV); +} + +int +evdev_set_report_size(struct evdev_dev *evdev, size_t report_size) +{ + if (report_size > KEY_CNT + REL_CNT + ABS_CNT + MAX_MT_SLOTS * MT_CNT + + MSC_CNT + LED_CNT + SND_CNT + SW_CNT + FF_CNT) + return (EINVAL); + + evdev->ev_report_size = report_size; + return (0); +} + +static size_t +evdev_estimate_report_size(struct evdev_dev *evdev) +{ + size_t size = 0; + int16_t i; + unsigned long type_detected; + + /* + * Keyboards generate one event per report but other devices with + * buttons like mouses can report events simultaneously + */ + type_detected = 0; + for (i = 0; i < KEY_CNT; i++) { + if (get_bit(evdev->ev_key_flags, i)) { + if (i >= BTN_MISC && i < KEY_OK) + size++; + else + type_detected = 1; + } + } + size += (type_detected != 0); + + /* All relative axes can be reported simultaneously */ + for (i = 0; i < REL_CNT; i++) + if (get_bit(evdev->ev_rel_flags, i)) + size++; + + /* + * All absolute axes can be reported simultaneously. + * Multitouch axes can be reported ABS_MT_SLOT times + */ + for (i = 0; i < ABS_CNT; i++) { + if (get_bit(evdev->ev_abs_flags, i)) { + if (ABS_IS_MT(i) || i == ABS_MT_SLOT) + size += MAX_MT_SLOTS; + else + size++; + } + } + + /* All misc events can be reported simultaneously */ + for (i = 0; i < MSC_CNT; i++) + if (get_bit(evdev->ev_msc_flags, i)) + size++; + + + /* All leds can be reported simultaneously */ + for (i = 0; i < LED_CNT; i++) + if (get_bit(evdev->ev_led_flags, i)) + size++; + + /* Assume other events are generated once per report */ + type_detected = 0; + for (i = 0; i < nlongs(SND_CNT); i++) + type_detected |= evdev->ev_snd_flags[i]; + size += (type_detected != 0); + + type_detected = 0; + for (i = 0; i < nlongs(SW_CNT); i++) + type_detected |= evdev->ev_sw_flags[i]; + size += (type_detected != 0); + + /* XXX: FF part is not implemented yet */ + + size++; /* SYN_REPORT */ + return (size); +} + +int +evdev_register(device_t dev, struct evdev_dev *evdev) +{ + int ret, i; + + device_printf(dev, "registered evdev provider: %s <%s>\n", + evdev->ev_name, evdev->ev_serial); + + /* Initialize internal structures */ + evdev->ev_dev = dev; + mtx_init(&evdev->ev_mtx, "evmtx", NULL, MTX_DEF); + LIST_INIT(&evdev->ev_clients); + + if (dev != NULL) + strlcpy(evdev->ev_shortname, device_get_nameunit(dev), NAMELEN); + + if ((evdev->ev_flags & EV_REPEAT_MASK) == EV_EVDEV_REPEAT) { + /* Initialize callout */ + callout_init(&evdev->ev_rep_callout, 1); + + if (evdev->ev_rep[REP_DELAY] == 0 && + evdev->ev_rep[REP_PERIOD] == 0) { + /* Supply default values */ + evdev->ev_rep[REP_DELAY] = 250; + evdev->ev_rep[REP_PERIOD] = 33; + } + } + + /* Retrieve bus info */ + evdev_assign_id(evdev); + + /* Initialize multitouch protocol type B states */ + for (i = 0; i < MAX_MT_SLOTS; i++) + evdev->ev_mt_states[i][ABS_MT_INDEX(ABS_MT_TRACKING_ID)] = -1; + + /* Estimate maximum report size */ + if (evdev->ev_report_size == 0) { + ret = evdev_set_report_size(evdev, + evdev_estimate_report_size(evdev)); + if (ret != 0) + goto bail_out; + } + + /* Create char device node */ + evdev->ev_flags |= EV_RUNNING; + ret = evdev_cdev_create(evdev); +bail_out: + if (ret != 0) + mtx_destroy(&evdev->ev_mtx); + + return (ret); +} + +int +evdev_unregister(device_t dev, struct evdev_dev *evdev) +{ + struct evdev_client *client; + int ret; + device_printf(dev, "unregistered evdev provider: %s\n", evdev->ev_name); + + EVDEV_LOCK(evdev); + evdev->ev_flags &= ~EV_RUNNING; + /* Wake up sleepers */ + LIST_FOREACH(client, &evdev->ev_clients, ec_link) { + EVDEV_CLIENT_LOCKQ(client); + if (client->ec_ev_notify != NULL) + client->ec_ev_notify(client, client->ec_ev_arg); + EVDEV_CLIENT_UNLOCKQ(client); + } + EVDEV_UNLOCK(evdev); + + /* destroy_dev can sleep so release lock */ + ret = evdev_cdev_destroy(evdev); + if (ret != 0) + return (ret); + + EVDEV_LOCK(evdev); + while (evdev->ev_clients_count > 0) + mtx_sleep(evdev, &evdev->ev_mtx, 0, "evunreg", 0); + EVDEV_UNLOCK(evdev); + mtx_destroy(&evdev->ev_mtx); + + return (0); +} + +inline void +evdev_set_name(struct evdev_dev *evdev, const char *name) +{ + + snprintf(evdev->ev_name, NAMELEN, "%s", name); +} + +inline void +evdev_set_phys(struct evdev_dev *evdev, const char *name) +{ + + snprintf(evdev->ev_shortname, NAMELEN, "%s", name); +} + +inline void +evdev_set_serial(struct evdev_dev *evdev, const char *serial) +{ + + snprintf(evdev->ev_serial, NAMELEN, "%s", serial); +} + +inline void +evdev_set_methods(struct evdev_dev *evdev, struct evdev_methods *methods) +{ + + evdev->ev_methods = methods; +} + +inline void +evdev_set_softc(struct evdev_dev *evdev, void *softc) +{ + + evdev->ev_softc = softc; +} + +inline int +evdev_support_prop(struct evdev_dev *evdev, uint16_t prop) +{ + + if (prop >= INPUT_PROP_CNT) + return (EINVAL); + + set_bit(evdev->ev_prop_flags, prop); + return (0); +} + +inline int +evdev_support_event(struct evdev_dev *evdev, uint16_t type) +{ + + if (type >= EV_CNT) + return (EINVAL); + + set_bit(evdev->ev_type_flags, type); + return (0); +} + +inline int +evdev_support_key(struct evdev_dev *evdev, uint16_t code) +{ + + if (code >= KEY_CNT) + return (EINVAL); + + set_bit(evdev->ev_key_flags, code); + return (0); +} + +inline int +evdev_support_rel(struct evdev_dev *evdev, uint16_t code) +{ + + if (code >= REL_CNT) + return (EINVAL); + + set_bit(evdev->ev_rel_flags, code); + return (0); +} + +inline int +evdev_support_abs(struct evdev_dev *evdev, uint16_t code) +{ + + if (code >= ABS_CNT) + return (EINVAL); + + set_bit(evdev->ev_abs_flags, code); + return (0); +} + + +inline int +evdev_support_msc(struct evdev_dev *evdev, uint16_t code) +{ + + if (code >= MSC_CNT) + return (EINVAL); + + set_bit(evdev->ev_msc_flags, code); + return (0); +} + + +inline int +evdev_support_led(struct evdev_dev *evdev, uint16_t code) +{ + + if (code >= LED_CNT) + return (EINVAL); + + set_bit(evdev->ev_led_flags, code); + return (0); +} + +inline int +evdev_support_snd(struct evdev_dev *evdev, uint16_t code) +{ + + if (code >= SND_CNT) + return (EINVAL); + + set_bit(evdev->ev_snd_flags, code); + return (0); +} + +inline int +evdev_support_sw(struct evdev_dev *evdev, uint16_t code) +{ + if (code >= SW_CNT) + return (EINVAL); + + set_bit(evdev->ev_sw_flags, code); + return (0); +} + +inline int +evdev_support_repeat(struct evdev_dev *evdev, int mode) +{ + + mode &= EV_REPEAT_MASK; + if (mode != EV_NO_REPEAT) + set_bit(evdev->ev_type_flags, EV_REP); + + evdev->ev_flags &= ~EV_REPEAT_MASK; + evdev->ev_flags |= mode; + return (0); +} + + +inline void +evdev_set_absinfo(struct evdev_dev *evdev, uint16_t axis, + struct input_absinfo *absinfo) +{ + + memcpy(&evdev->ev_absinfo[axis], absinfo, sizeof(struct input_absinfo)); +} + +inline void +evdev_set_repeat_params(struct evdev_dev *evdev, uint16_t property, int value) +{ + + KASSERT(property < REP_CNT, ("invalid evdev repeat property")); + evdev->ev_rep[property] = value; +} + +static int +evdev_check_event(struct evdev_dev *evdev, uint16_t type, uint16_t code, + int32_t value) +{ + + switch (type) { + case EV_SYN: + if (code >= SYN_CNT) + return (EINVAL); + break; + + case EV_KEY: + if (code >= KEY_CNT) + return (EINVAL); + if (!get_bit(evdev->ev_key_flags, code)) + return (EINVAL); + break; + + case EV_REL: + if (code >= REL_CNT) + return (EINVAL); + if (!get_bit(evdev->ev_rel_flags, code)) + return (EINVAL); + break; + + case EV_ABS: + if (code >= ABS_CNT) + return (EINVAL); + if (!get_bit(evdev->ev_abs_flags, code)) + return (EINVAL); + if (code == ABS_MT_SLOT && value >= MAX_MT_SLOTS) + return (EINVAL); + break; + + case EV_MSC: + if (code >= MSC_CNT) + return (EINVAL); + if (!get_bit(evdev->ev_msc_flags, code)) + return (EINVAL); + break; + + case EV_LED: + if (code >= LED_CNT) + return (EINVAL); + if (!get_bit(evdev->ev_led_flags, code)) + return (EINVAL); + break; + + case EV_SND: + if (code >= SND_CNT) + return (EINVAL); + if (!get_bit(evdev->ev_snd_flags, code)) + return (EINVAL); + break; + + case EV_SW: + if (code >= SW_CNT) + return (EINVAL); + if (!get_bit(evdev->ev_sw_flags, code)) + return (EINVAL); + break; + + default: + return (EINVAL); + } + + /* Allow SYN events implicitly */ + if (type != EV_SYN && !get_bit(evdev->ev_type_flags, type)) + return (EINVAL); + + return (0); +} + +int +evdev_push_event(struct evdev_dev *evdev, uint16_t type, uint16_t code, + int32_t value) +{ + struct evdev_client *client; + int32_t postponed_mt_slot = -1; + + if (evdev_check_event(evdev, type, code, value) != 0) + return (EINVAL); + + debugf("%s pushed event %d/%d/%d", + evdev->ev_shortname, type, code, value); + + /* + * For certain event types, update device state bits + * and convert level reporting to edge reporting + */ + switch (type) { + case EV_KEY: + if (get_bit(evdev->ev_key_states, code) == + (value != KEY_EVENT_UP)) { + /* Detect key repeats. */ + if ((evdev->ev_flags & EV_REPEAT_MASK) == + EV_DRIVER_REPEAT && value != KEY_EVENT_UP) + value = KEY_EVENT_REPEAT; + else + return (0); + } else + change_bit(evdev->ev_key_states, code, value); + break; + + case EV_LED: + if (get_bit(evdev->ev_led_states, code) == value) + return (0); + change_bit(evdev->ev_led_states, code, value); + break; + + case EV_SND: + if (get_bit(evdev->ev_snd_states, code) == value) + return (0); + change_bit(evdev->ev_snd_states, code, value); + break; + + case EV_SW: + if (get_bit(evdev->ev_sw_states, code) == value) + return (0); + change_bit(evdev->ev_sw_states, code, value); + break; + + /* For EV_ABS, save last value in absinfo and ev_mt_states */ + case EV_ABS: + switch (code) { + case ABS_MT_SLOT: + /* Postpone ABS_MT_SLOT till next event */ + evdev->last_reported_mt_slot = value; + return (0); + + case ABS_MT_FIRST ... ABS_MT_LAST: + /* Don`t repeat MT protocol type B events */ + if (evdev->ev_mt_states[evdev->last_reported_mt_slot] + [ABS_MT_INDEX(code)] == value) + return (0); + evdev->ev_mt_states[evdev->last_reported_mt_slot] + [ABS_MT_INDEX(code)] = value; + if (evdev->last_reported_mt_slot != + CURRENT_MT_SLOT(evdev)) { + CURRENT_MT_SLOT(evdev) = + evdev->last_reported_mt_slot; + postponed_mt_slot = CURRENT_MT_SLOT(evdev); + } + break; + + default: + /* XXX: Do we need MT protocol type A handling ??? */ + if (evdev->ev_absinfo[code].value == value) + return (0); + evdev->ev_absinfo[code].value = value; + } + break; + } + + /* Skip empty reports */ + if (type == EV_SYN && code == SYN_REPORT) { + if (evdev->events_since_last_syn == 0) + return (0); + evdev->events_since_last_syn = 0; + } else { + evdev->events_since_last_syn++; + } + + /* Propagate event through all clients */ + EVDEV_LOCK(evdev); + LIST_FOREACH(client, &evdev->ev_clients, ec_link) { + if (!client->ec_enabled) + continue; + + EVDEV_CLIENT_LOCKQ(client); + /* report postponed ABS_MT_SLOT */ + if (postponed_mt_slot != -1) + evdev_client_push(client, + EV_ABS, ABS_MT_SLOT, postponed_mt_slot); + evdev_client_push(client, type, code, value); + + if (client->ec_ev_notify != NULL && + type == EV_SYN && code == SYN_REPORT) + client->ec_ev_notify(client, client->ec_ev_arg); + EVDEV_CLIENT_UNLOCKQ(client); + } + EVDEV_UNLOCK(evdev); + + return (0); +} + +int +evdev_inject_event(struct evdev_dev *evdev, uint16_t type, uint16_t code, + int32_t value) +{ + + if (evdev->ev_methods->ev_event != NULL) { + evdev->ev_methods->ev_event(evdev, evdev->ev_softc, type, + code, value); + } + + return (0); +} + +inline int +evdev_sync(struct evdev_dev *evdev) +{ + + return (evdev_push_event(evdev, EV_SYN, SYN_REPORT, 1)); +} + + +inline int +evdev_mt_sync(struct evdev_dev *evdev) +{ + + return (evdev_push_event(evdev, EV_SYN, SYN_MT_REPORT, 1)); +} + +int +evdev_register_client(struct evdev_dev *evdev, struct evdev_client **clientp) +{ + struct evdev_client *client; + size_t buffer_size; + + /* Initialize client structure */ + buffer_size = evdev->ev_report_size * DEF_RING_REPORTS; + client = malloc(offsetof(struct evdev_client, ec_buffer_size) + + sizeof(struct input_event) * buffer_size, + M_EVDEV, M_WAITOK | M_ZERO); + mtx_init(&client->ec_buffer_mtx, "evclient", NULL, MTX_DEF); + client->ec_evdev = evdev; + + /* Initialize ring buffer */ + client->ec_buffer_size = buffer_size; + client->ec_buffer_head = 0; + client->ec_buffer_tail = 0; + client->ec_buffer_ready = 0; + client->ec_enabled = true; + + debugf("adding new client for device %s", evdev->ev_shortname); + + EVDEV_LOCK(evdev); + if (evdev->ev_clients_count == 0 && evdev->ev_methods != NULL && + evdev->ev_methods->ev_open != NULL) { + debugf("calling ev_open() on device %s", evdev->ev_shortname); + evdev->ev_methods->ev_open(evdev, evdev->ev_softc); + } + LIST_INSERT_HEAD(&evdev->ev_clients, client, ec_link); + evdev->ev_clients_count++; + EVDEV_UNLOCK(evdev); + *clientp = client; + return (0); +} + +int +evdev_dispose_client(struct evdev_client *client) +{ + struct evdev_dev *evdev = client->ec_evdev; + + debugf("removing client for device %s", evdev->ev_shortname); + + EVDEV_LOCK(evdev); + evdev->ev_clients_count--; + if (evdev->ev_clients_count == 0 && evdev->ev_methods != NULL && + evdev->ev_methods->ev_close != NULL) + evdev->ev_methods->ev_close(evdev, evdev->ev_softc); + + LIST_REMOVE(client, ec_link); + if (!(evdev->ev_flags & EV_RUNNING) && evdev->ev_clients_count == 0) + wakeup(evdev); + EVDEV_UNLOCK(evdev); + + free(client, M_EVDEV); + return (0); +} + +int +evdev_grab_client(struct evdev_client *client) +{ + struct evdev_dev *evdev = client->ec_evdev; + struct evdev_client *iter; + + EVDEV_LOCK(evdev); + if (evdev->ev_flags & EV_GRABBED) { + EVDEV_UNLOCK(evdev); + return (EBUSY); + } + + evdev->ev_flags |= EV_GRABBED; + + /* Disable all other clients */ + LIST_FOREACH(iter, &evdev->ev_clients, ec_link) { + if (iter != client) + iter->ec_enabled = false; + } + + EVDEV_UNLOCK(evdev); + return (0); +} + +int +evdev_release_client(struct evdev_client *client) +{ + struct evdev_dev *evdev = client->ec_evdev; + struct evdev_client *iter; + + EVDEV_LOCK(evdev); + if (!(evdev->ev_flags & EV_GRABBED)) { + EVDEV_UNLOCK(evdev); + return (EINVAL); + } + + evdev->ev_flags &= ~EV_GRABBED; + + /* Enable all other clients */ + LIST_FOREACH(iter, &evdev->ev_clients, ec_link) { + iter->ec_enabled = true; + } + + EVDEV_UNLOCK(evdev); + return (0); +} + +static void +evdev_assign_id(struct evdev_dev *dev) +{ + device_t parent; + devclass_t devclass; + const char *classname; + + if (dev->ev_id.bustype != 0) + return; + + if (dev->ev_dev == NULL) { + dev->ev_id.bustype = BUS_VIRTUAL; + return; + } + + parent = device_get_parent(dev->ev_dev); + if (parent == NULL) { + dev->ev_id.bustype = BUS_HOST; + return; + } + + devclass = device_get_devclass(parent); + classname = devclass_get_name(devclass); + + debugf("parent bus classname: %s", classname); + + if (strcmp(classname, "pci") == 0) { + dev->ev_id.bustype = BUS_PCI; + dev->ev_id.vendor = pci_get_vendor(dev->ev_dev); + dev->ev_id.product = pci_get_device(dev->ev_dev); + dev->ev_id.version = pci_get_revid(dev->ev_dev); + return; + } + + if (strcmp(classname, "uhub") == 0) { + struct usb_attach_arg *uaa = device_get_ivars(dev->ev_dev); + dev->ev_id.bustype = BUS_USB; + dev->ev_id.vendor = uaa->info.idVendor; + dev->ev_id.product = uaa->info.idProduct; + return; + } + + if (strcmp(classname, "atkbdc") == 0) { + devclass = device_get_devclass(dev->ev_dev); + classname = devclass_get_name(devclass); + dev->ev_id.bustype = BUS_I8042; + if (strcmp(classname, "atkbd") == 0) { + dev->ev_id.vendor = PS2_KEYBOARD_VENDOR; + dev->ev_id.product = PS2_KEYBOARD_PRODUCT; + } else if (strcmp(classname, "psm") == 0) { + dev->ev_id.vendor = PS2_MOUSE_VENDOR; + dev->ev_id.product = PS2_MOUSE_GENERIC_PRODUCT; + } + return; + } + + dev->ev_id.bustype = BUS_HOST; +} + +#if 0 +static void +evdev_start_repeat(struct evdev_dev *dev, int32_t key) +{ + +} + +static void +evdev_stop_repeat(struct evdev_dev *dev) +{ + +} +#endif + +static void +evdev_client_gettime(struct evdev_client *client, struct timeval *tv) +{ + + if (client->ec_clock_id == EV_CLOCK_MONOTONIC) + microuptime(tv); + else + microtime(tv); +} + +static void +evdev_client_push(struct evdev_client *client, uint16_t type, uint16_t code, + int32_t value) +{ + struct timeval time; + size_t count, head, tail, ready; + + EVDEV_CLIENT_LOCKQ_ASSERT(client); + head = client->ec_buffer_head; + tail = client->ec_buffer_tail; + ready = client->ec_buffer_ready; + count = client->ec_buffer_size; + + /* If queue is full drop its content and place SYN_DROPPED event */ +again: + if ((tail + 1) % count == head) { + /* If queue reading in progress postpone dropping till end */ + if (client->ec_read) { + client->ec_overflown = true; + mtx_sleep(client, &client->ec_buffer_mtx, 0, "evovfl", + 0); + client->ec_overflown = false; + goto again; + } + debugf("client %p for device %s: buffer overflow", client, + client->ec_evdev->ev_shortname); + + head = (tail + count - 1) % count; + client->ec_buffer[head] = (struct input_event) { + .type = EV_SYN, + .code = SYN_DROPPED, + .value = 0 + }; + /* + * XXX: Here is a small race window from now till the end of + * report. The queue is empty but client has been already + * notified of data readyness. Can be fixed in two ways: + * 1. Implement bulk insert so queue lock would not be dropped + * till the SYN_REPORT event. + * 2. Insert SYN_REPORT just now and skip remaining events + */ + client->ec_buffer_head = head; + client->ec_buffer_ready = head; + } + + client->ec_buffer[tail].type = type; + client->ec_buffer[tail].code = code; + client->ec_buffer[tail].value = value; + client->ec_buffer_tail = (tail + 1) % count; + + /* Allow users to read events only after report has been completed */ + if (type == EV_SYN && code == SYN_REPORT) { + evdev_client_gettime(client, &time); + for (; ready != client->ec_buffer_tail; + ready = (ready + 1) % count) + client->ec_buffer[ready].time = time; + client->ec_buffer_ready = client->ec_buffer_tail; + } +} + +void +evdev_client_dumpqueue(struct evdev_client *client) +{ + struct input_event *event; + size_t i, head, tail, ready, size; + + head = client->ec_buffer_head; + tail = client->ec_buffer_tail; + ready = client->ec_buffer_ready; + size = client->ec_buffer_size; + + printf("evdev client: %p\n", client); + printf("evdev provider name: %s\n", client->ec_evdev->ev_name); + printf("event queue: head=%zu ready=%zu tail=%zu size=%zu\n", + head, ready, tail, size); + + printf("queue contents:\n"); + + for (i = 0; i < size; i++) { + event = &client->ec_buffer[i]; + printf("%zu: ", i); + + if (i < head || i > tail) + printf("unused\n"); + else + printf("type=%d code=%d value=%d ", event->type, + event->code, event->value); + + if (i == head) + printf("<- head\n"); + else if (i == tail) + printf("<- tail\n"); + else if (i == ready) + printf("<- ready\n"); + else + printf("\n"); + } +} + +void +evdev_client_filter_queue(struct evdev_client *client, uint16_t type) +{ + struct input_event *event; + size_t head, tail, count, i; + bool last_was_syn = false; + + EVDEV_CLIENT_LOCKQ(client); + + i = head = client->ec_buffer_head; + tail = client->ec_buffer_tail; + count = client->ec_buffer_size; + client->ec_buffer_ready = client->ec_buffer_tail; + + while (i != client->ec_buffer_tail) { + event = &client->ec_buffer[i]; + i = (i + 1) % count; + + /* Skip event of given type */ + if (event->type == type) + continue; + + /* Remove empty SYN_REPORT events */ + if (event->type == EV_SYN && event->code == SYN_REPORT) { + if (last_was_syn) + continue; + else + client->ec_buffer_ready = (tail + 1) % count; + } + + /* Rewrite entry */ + memcpy(&client->ec_buffer[tail], event, + sizeof(struct input_event)); + + last_was_syn = (event->type == EV_SYN && + event->code == SYN_REPORT); + + tail = (tail + 1) % count; + } + + client->ec_buffer_head = i; + client->ec_buffer_tail = tail; + + EVDEV_CLIENT_UNLOCKQ(client); +} diff --git a/sys/dev/evdev/evdev.h b/sys/dev/evdev/evdev.h new file mode 100644 index 0000000..4c52d34 --- /dev/null +++ b/sys/dev/evdev/evdev.h @@ -0,0 +1,228 @@ +/*- + * Copyright (c) 2014 Jakub Wojciech Klama + * All rights reserved. + * + * 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. + * + * $FreeBSD$ + */ + +#ifndef _DEV_EVDEV_EVDEV_H +#define _DEV_EVDEV_EVDEV_H + +#include +#include +#include + +#define NAMELEN 80 +#define LONG_WIDTH (sizeof(unsigned long) * 8) +#define nlongs(x) (howmany(x, sizeof(unsigned long) * 8)) + +MALLOC_DECLARE(M_EVDEV); + +struct evdev_dev; +struct evdev_client; + +typedef int (evdev_open_t)(struct evdev_dev *, void *); +typedef void (evdev_close_t)(struct evdev_dev *, void *); +typedef void (evdev_event_t)(struct evdev_dev *, void *, uint16_t, + uint16_t, int32_t); +typedef void (evdev_keycode_t)(struct evdev_dev *, void *, + struct input_keymap_entry *); +typedef void (evdev_client_event_t)(struct evdev_client *, void *); + +/* Multitouch protocol type B interface */ +#define MAX_MT_SLOTS 16 +#define ABS_MT_FIRST ABS_MT_TOUCH_MAJOR +#define ABS_MT_LAST ABS_MT_TOOL_Y +#define ABS_IS_MT(x) ((x) >= ABS_MT_FIRST && (x) <= ABS_MT_LAST) +#define ABS_MT_INDEX(x) ((x) - ABS_MT_FIRST) +#define MT_CNT (ABS_MT_INDEX(ABS_MT_LAST) + 1) +#define CURRENT_MT_SLOT(evdev) ((evdev)->ev_absinfo[ABS_MT_SLOT].value) + +struct input_mt_request_layout { + uint32_t code; + int32_t values[MAX_MT_SLOTS]; +}; + +enum evdev_key_events +{ + KEY_EVENT_UP, + KEY_EVENT_DOWN, + KEY_EVENT_REPEAT +}; + +enum evdev_clock_id +{ + EV_CLOCK_REALTIME = 0, + EV_CLOCK_MONOTONIC +}; + +#define PS2_KEYBOARD_VENDOR 1 +#define PS2_KEYBOARD_PRODUCT 1 +#define PS2_MOUSE_VENDOR 2 +#define PS2_MOUSE_GENERIC_PRODUCT 1 + +struct evdev_methods +{ + evdev_open_t *ev_open; + evdev_close_t *ev_close; + evdev_event_t *ev_event; + evdev_keycode_t *ev_get_keycode; + evdev_keycode_t *ev_set_keycode; +}; + +struct evdev_dev +{ + char ev_name[NAMELEN]; + char ev_shortname[NAMELEN]; + char ev_serial[NAMELEN]; + device_t ev_dev; + void * ev_softc; + struct cdev * ev_cdev; + int ev_unit; + struct mtx ev_mtx; + struct input_id ev_id; +#define EV_NO_REPEAT 0x0000 +#define EV_DRIVER_REPEAT 0x0001 +#define EV_EVDEV_REPEAT 0x0002 +#define EV_REPEAT_MASK 0x0003 +#define EV_GRABBED 0x0004 +#define EV_RUNNING 0x0008 + int ev_flags; + size_t ev_report_size; + + /* Supported features: */ + unsigned long ev_prop_flags[nlongs(INPUT_PROP_CNT)]; + unsigned long ev_type_flags[nlongs(EV_CNT)]; + unsigned long ev_key_flags[nlongs(KEY_CNT)]; + unsigned long ev_rel_flags[nlongs(REL_CNT)]; + unsigned long ev_abs_flags[nlongs(ABS_CNT)]; + unsigned long ev_msc_flags[nlongs(MSC_CNT)]; + unsigned long ev_led_flags[nlongs(LED_CNT)]; + unsigned long ev_snd_flags[nlongs(SND_CNT)]; + unsigned long ev_sw_flags[nlongs(SW_CNT)]; + struct input_absinfo ev_absinfo[ABS_CNT]; + + /* Repeat parameters & callout: */ + int ev_rep[REP_CNT]; + struct callout ev_rep_callout; + + /* State: */ + unsigned long ev_key_states[nlongs(KEY_CNT)]; + unsigned long ev_led_states[nlongs(LED_CNT)]; + unsigned long ev_snd_states[nlongs(SND_CNT)]; + unsigned long ev_sw_states[nlongs(SW_CNT)]; + + /* Multitouch protocol type B state: */ + int32_t last_reported_mt_slot; + int32_t ev_mt_states[MAX_MT_SLOTS][MT_CNT]; + int events_since_last_syn; + + /* Counters: */ + uint64_t ev_event_count; + int ev_clients_count; + + struct evdev_methods * ev_methods; + + LIST_ENTRY(evdev_dev) ev_link; + LIST_HEAD(, evdev_client) ev_clients; +}; + +#define EVDEV_LOCK(evdev) mtx_lock(&(evdev)->ev_mtx) +#define EVDEV_UNLOCK(evdev) mtx_unlock(&(evdev)->ev_mtx) + +struct evdev_client +{ + struct evdev_dev * ec_evdev; + struct mtx ec_buffer_mtx; + size_t ec_buffer_size; + size_t ec_buffer_head; + size_t ec_buffer_tail; + size_t ec_buffer_ready; + bool ec_enabled; + bool ec_stall; + bool ec_read; + bool ec_overflown; + enum evdev_clock_id ec_clock_id; + + evdev_client_event_t * ec_ev_notify; + void * ec_ev_arg; + + LIST_ENTRY(evdev_client) ec_link; + + struct input_event ec_buffer[]; +}; + +#define EVDEV_CLIENT_LOCKQ(client) mtx_lock(&(client)->ec_buffer_mtx) +#define EVDEV_CLIENT_UNLOCKQ(client) mtx_unlock(&(client)->ec_buffer_mtx) +#define EVDEV_CLIENT_LOCKQ_ASSERT(client) \ + mtx_assert(&(client)->ec_buffer_mtx, MA_OWNED) +#define EVDEV_CLIENT_EMPTYQ(client) \ + ((client)->ec_buffer_head == (client)->ec_buffer_ready) + +/* Input device interface: */ +struct evdev_dev *evdev_alloc(void); +void evdev_free(struct evdev_dev *); +void evdev_set_name(struct evdev_dev *, const char *); +void evdev_set_phys(struct evdev_dev *, const char *); +void evdev_set_serial(struct evdev_dev *, const char *); +void evdev_set_methods(struct evdev_dev *, struct evdev_methods *); +void evdev_set_softc(struct evdev_dev *, void *); +int evdev_register(device_t, struct evdev_dev *); +int evdev_unregister(device_t, struct evdev_dev *); +int evdev_push_event(struct evdev_dev *, uint16_t, uint16_t, int32_t); +int evdev_inject_event(struct evdev_dev *, uint16_t, uint16_t, int32_t); +int evdev_sync(struct evdev_dev *); +int evdev_mt_sync(struct evdev_dev *); +int evdev_cdev_create(struct evdev_dev *); +int evdev_cdev_destroy(struct evdev_dev *); +int evdev_support_prop(struct evdev_dev *, uint16_t); +int evdev_support_event(struct evdev_dev *, uint16_t); +int evdev_support_key(struct evdev_dev *, uint16_t); +int evdev_support_rel(struct evdev_dev *, uint16_t); +int evdev_support_abs(struct evdev_dev *, uint16_t); +int evdev_support_msc(struct evdev_dev *, uint16_t); +int evdev_support_led(struct evdev_dev *, uint16_t); +int evdev_support_snd(struct evdev_dev *, uint16_t); +int evdev_support_sw(struct evdev_dev *, uint16_t); +int evdev_support_repeat(struct evdev_dev *, int); +void evdev_set_absinfo(struct evdev_dev *, uint16_t, struct input_absinfo *); +void evdev_set_repeat_params(struct evdev_dev *, uint16_t, int); +int evdev_set_report_size(struct evdev_dev *, size_t); + +/* Client interface: */ +int evdev_register_client(struct evdev_dev *, struct evdev_client **); +int evdev_dispose_client(struct evdev_client *); +int evdev_grab_client(struct evdev_client *); +int evdev_release_client(struct evdev_client *); +void evdev_client_filter_queue(struct evdev_client *, uint16_t); + +/* Utility functions: */ +uint16_t evdev_hid2key(int); +void evdev_support_all_known_keys(struct evdev_dev *); +uint16_t evdev_scancode2key(int *, int); +void evdev_client_dumpqueue(struct evdev_client *); +void evdev_push_mouse_btn(struct evdev_dev *, int); +void evdev_push_leds(struct evdev_dev *, int); + +#endif /* _DEV_EVDEV_EVDEV_H */ diff --git a/sys/dev/evdev/evdev_utils.c b/sys/dev/evdev/evdev_utils.c new file mode 100644 index 0000000..138f03d --- /dev/null +++ b/sys/dev/evdev/evdev_utils.c @@ -0,0 +1,283 @@ +/*- + * Copyright (c) 2014 Jakub Wojciech Klama + * All rights reserved. + * + * 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. + * + * $FreeBSD$ + */ + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#define NONE KEY_RESERVED + +static uint16_t evdev_usb_scancodes[256] = { + /* 0x00 - 0x27 */ + NONE, NONE, NONE, NONE, KEY_A, KEY_B, KEY_C, KEY_D, + KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J, KEY_K, KEY_L, + KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T, + KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z, KEY_1, KEY_2, + KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0, + /* 0x28 - 0x3f */ + KEY_ENTER, KEY_ESC, KEY_BACKSPACE, KEY_TAB, + KEY_SPACE, KEY_MINUS, KEY_EQUAL, KEY_LEFTBRACE, + KEY_RIGHTBRACE, KEY_BACKSLASH, KEY_BACKSLASH, KEY_SEMICOLON, + KEY_APOSTROPHE, KEY_GRAVE, KEY_COMMA, KEY_DOT, + KEY_SLASH, KEY_CAPSLOCK, KEY_F1, KEY_F2, + KEY_F3, KEY_F4, KEY_F5, KEY_F6, + /* 0x40 - 0x5f */ + KEY_F7, KEY_F8, KEY_F9, KEY_F10, + KEY_F11, KEY_F12, KEY_SYSRQ, KEY_SCROLLLOCK, + KEY_PAUSE, KEY_INSERT, KEY_HOME, KEY_PAGEUP, + KEY_DELETE, KEY_END, KEY_PAGEDOWN, KEY_RIGHT, + KEY_LEFT, KEY_DOWN, KEY_UP, KEY_NUMLOCK, + KEY_SLASH, KEY_KPASTERISK, KEY_KPMINUS, KEY_KPPLUS, + KEY_KPENTER, KEY_KP1, KEY_KP2, KEY_KP3, + KEY_KP4, KEY_KP5, KEY_KP6, KEY_KP7, + /* 0x60 - 0x7f */ + KEY_KP8, KEY_KP9, KEY_KP0, KEY_KPDOT, + KEY_102ND, KEY_COMPOSE, KEY_POWER, KEY_KPEQUAL, + KEY_F13, KEY_F14, KEY_F15, KEY_F16, + KEY_F17, KEY_F18, KEY_F19, KEY_F20, + KEY_F21, KEY_F22, KEY_F23, KEY_F24, + KEY_OPEN, KEY_HELP, KEY_PROPS, KEY_FRONT, + KEY_STOP, KEY_AGAIN, KEY_UNDO, KEY_CUT, + KEY_COPY, KEY_PASTE, KEY_FIND, KEY_MUTE, + /* 0x80 - 0x9f */ + KEY_VOLUMEUP, KEY_VOLUMEDOWN, NONE, NONE, + NONE, KEY_KPCOMMA, NONE, KEY_RO, + KEY_KATAKANAHIRAGANA, KEY_YEN,KEY_HENKAN, KEY_MUHENKAN, + KEY_KPJPCOMMA, NONE, NONE, NONE, + KEY_HANGEUL, KEY_HANJA, KEY_KATAKANA, KEY_HIRAGANA, + KEY_ZENKAKUHANKAKU, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + /* 0xa0 - 0xbf */ + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + /* 0xc0 - 0xdf */ + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + /* 0xe0 - 0xff */ + KEY_LEFTCTRL, KEY_LEFTSHIFT, KEY_LEFTALT, KEY_LEFTMETA, + KEY_RIGHTCTRL, KEY_RIGHTSHIFT, KEY_RIGHTALT, KEY_RIGHTMETA, + KEY_PLAYPAUSE, KEY_STOPCD, KEY_PREVIOUSSONG,KEY_NEXTSONG, + KEY_EJECTCD, KEY_VOLUMEUP, KEY_VOLUMEDOWN, KEY_MUTE, + KEY_WWW, KEY_BACK, KEY_FORWARD, KEY_STOP, + KEY_FIND, KEY_SCROLLUP, KEY_SCROLLDOWN, KEY_EDIT, + KEY_SLEEP, KEY_COFFEE, KEY_REFRESH, KEY_CALC, + NONE, NONE, NONE, NONE, + +}; + +static uint16_t evdev_at_set1_scancodes[] = { + /* 0x00 - 0x1f */ + NONE, KEY_ESC, KEY_1, KEY_2, + KEY_3, KEY_4, KEY_5, KEY_6, + KEY_7, KEY_8, KEY_9, KEY_0, + KEY_MINUS, KEY_EQUAL, KEY_BACKSPACE, KEY_TAB, + KEY_Q, KEY_W, KEY_E, KEY_R, + KEY_T, KEY_Y, KEY_U, KEY_I, + KEY_O, KEY_P, KEY_LEFTBRACE, KEY_RIGHTBRACE, + KEY_ENTER, KEY_LEFTCTRL, KEY_A, KEY_S, + /* 0x20 - 0x3f */ + KEY_D, KEY_F, KEY_G, KEY_H, + KEY_J, KEY_K, KEY_L, KEY_SEMICOLON, + KEY_APOSTROPHE, KEY_GRAVE, KEY_LEFTSHIFT, KEY_BACKSLASH, + KEY_Z, KEY_X, KEY_C, KEY_V, + KEY_B, KEY_N, KEY_M, KEY_COMMA, + KEY_DOT, KEY_SLASH, KEY_RIGHTSHIFT, NONE, + KEY_LEFTALT, KEY_SPACE, KEY_CAPSLOCK, KEY_F1, + KEY_F2, KEY_F3, KEY_F4, KEY_F5, + /* 0x40 - 0x5f */ + KEY_F6, KEY_F7, KEY_F8, KEY_F9, + KEY_F10, KEY_NUMLOCK, KEY_SCROLLLOCK, KEY_KP7, + KEY_KP8, KEY_KP9, KEY_KPMINUS, KEY_KP4, + KEY_KP5, KEY_KP6, KEY_KPPLUS, KEY_KP1, + KEY_KP2, KEY_KP3, KEY_KP0, KEY_KPDOT, + NONE, NONE, NONE, KEY_F11, + KEY_F12, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + /* 0x60 - 0x7f */ + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + KEY_KATAKANAHIRAGANA, NONE, NONE, KEY_RO, + NONE, NONE, KEY_ZENKAKUHANKAKU, KEY_HIRAGANA, + KEY_KATAKANA, KEY_HENKAN, NONE, KEY_MUHENKAN, + NONE, KEY_YEN, KEY_KPCOMMA, NONE, + /* 0x00 - 0x1f. 0xE0 prefixed */ + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + KEY_PREVIOUSSONG, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, KEY_NEXTSONG, NONE, NONE, + NONE, KEY_KPENTER, KEY_RIGHTCTRL, NONE, + /* 0x20 - 0x3f. 0xE0 prefixed */ + KEY_MUTE, KEY_CALC, KEY_PLAYPAUSE, NONE, + KEY_STOPCD, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, KEY_VOLUMEDOWN, NONE, + KEY_VOLUMEUP, NONE, KEY_HOMEPAGE, NONE, + NONE, KEY_KPASTERISK, NONE, KEY_SYSRQ, + KEY_RIGHTALT, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + /* 0x40 - 0x5f. 0xE0 prefixed */ + NONE, NONE, NONE, NONE, + NONE, NONE, KEY_PAUSE, KEY_HOME, + KEY_UP, KEY_PAGEUP, NONE, KEY_LEFT, + NONE, KEY_RIGHT, NONE, KEY_END, + KEY_DOWN, KEY_PAGEDOWN, KEY_INSERT, KEY_DELETE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, KEY_LEFTMETA, + KEY_RIGHTMETA, KEY_MENU, KEY_POWER, KEY_SLEEP, + /* 0x60 - 0x7f. 0xE0 prefixed */ + NONE, NONE, NONE, KEY_WAKEUP, + NONE, KEY_SEARCH, KEY_BOOKMARKS, KEY_REFRESH, + KEY_STOP, KEY_FORWARD, KEY_BACK, KEY_COMPUTER, + KEY_MAIL, KEY_MEDIA, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, + NONE, NONE, NONE, NONE, +}; + +static uint16_t evdev_mouse_button_codes[] = { + BTN_LEFT, + BTN_MIDDLE, + BTN_RIGHT, + BTN_SIDE, + BTN_EXTRA, + BTN_FORWARD, + BTN_BACK, + BTN_TASK, +}; + +static uint16_t evdev_led_codes[] = { + LED_CAPSL, /* CLKED */ + LED_NUML, /* NLKED */ + LED_SCROLLL, /* SLKED */ +}; + + +inline uint16_t +evdev_hid2key(int scancode) +{ + return evdev_usb_scancodes[scancode]; +} + +inline void +evdev_support_all_known_keys(struct evdev_dev *evdev) +{ + size_t i; + + for (i = KEY_RESERVED; i < nitems(evdev_at_set1_scancodes); i++) + if (evdev_at_set1_scancodes[i] != NONE) + evdev_support_key(evdev, evdev_at_set1_scancodes[i]); +} + +inline uint16_t +evdev_scancode2key(int *state, int scancode) +{ + uint16_t keycode; + + /* translate the scan code into a keycode */ + keycode = evdev_at_set1_scancodes[scancode & 0x7f]; + switch (*state) { + case 0x00: /* normal scancode */ + switch(scancode) { + case 0xE0: + case 0xE1: + *state = scancode; + return (NONE); + } + break; + case 0xE0: /* 0xE0 prefix */ + *state = 0; + keycode = evdev_at_set1_scancodes[0x80 + (scancode & 0x7f)]; + break; + case 0xE1: /* 0xE1 prefix */ + /* + * The pause/break key on the 101 keyboard produces: + * E1-1D-45 E1-9D-C5 + * Ctrl-pause/break produces: + * E0-46 E0-C6 (See above.) + */ + *state = 0; + if ((scancode & 0x7f) == 0x1D) + *state = 0x1D; + return (NONE); + /* NOT REACHED */ + case 0x1D: /* pause / break */ + *state = 0; + if (scancode != 0x45) + return (NONE); + keycode = KEY_PAUSE; + break; + } + + return (keycode); +} + +void +evdev_push_mouse_btn(struct evdev_dev *evdev, int buttons) +{ + size_t i; + + for (i = 0; i < nitems(evdev_mouse_button_codes); i++) + evdev_push_event(evdev, EV_KEY, evdev_mouse_button_codes[i], + (buttons & (1 << i)) != 0); +} + +void +evdev_push_leds(struct evdev_dev *evdev, int leds) +{ + size_t i; + + for (i = 0; i < nitems(evdev_led_codes); i++) + evdev_push_event(evdev, EV_LED, evdev_led_codes[i], + (leds & (1 << i)) != 0); +} diff --git a/sys/dev/evdev/input.h b/sys/dev/evdev/input.h new file mode 100644 index 0000000..3999dbd --- /dev/null +++ b/sys/dev/evdev/input.h @@ -0,0 +1,1205 @@ +/* + * 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. + */ +#ifndef _UAPI_INPUT_H +#define _UAPI_INPUT_H + + +#ifndef __KERNEL__ +#include +#include +#include +#endif + + +/* + * The event structure itself + */ + +struct input_event { + struct timeval time; + uint16_t type; + uint16_t code; + int32_t value; +}; + +/* + * Protocol version. + */ + +#define EV_VERSION 0x010001 + +/* + * IOCTLs (0x00 - 0x7f) + */ + +struct input_id { + uint16_t bustype; + uint16_t vendor; + uint16_t product; + uint16_t version; +}; + +/** + * struct input_absinfo - used by EVIOCGABS/EVIOCSABS ioctls + * @value: latest reported value for the axis. + * @minimum: specifies minimum value for the axis. + * @maximum: specifies maximum value for the axis. + * @fuzz: specifies fuzz value that is used to filter noise from + * the event stream. + * @flat: values that are within this value will be discarded by + * joydev interface and reported as 0 instead. + * @resolution: specifies resolution for the values reported for + * the axis. + * + * Note that input core does not clamp reported values to the + * [minimum, maximum] limits, such task is left to userspace. + * + * Resolution for main axes (ABS_X, ABS_Y, ABS_Z) is reported in + * units per millimeter (units/mm), resolution for rotational axes + * (ABS_RX, ABS_RY, ABS_RZ) is reported in units per radian. + */ +struct input_absinfo { + int32_t value; + int32_t minimum; + int32_t maximum; + int32_t fuzz; + int32_t flat; + int32_t resolution; +}; + +/** + * struct input_keymap_entry - used by EVIOCGKEYCODE/EVIOCSKEYCODE ioctls + * @scancode: scancode represented in machine-endian form. + * @len: length of the scancode that resides in @scancode buffer. + * @index: index in the keymap, may be used instead of scancode + * @flags: allows to specify how kernel should handle the request. For + * example, setting INPUT_KEYMAP_BY_INDEX flag indicates that kernel + * should perform lookup in keymap by @index instead of @scancode + * @keycode: key code assigned to this scancode + * + * The structure is used to retrieve and modify keymap data. Users have + * option of performing lookup either by @scancode itself or by @index + * in keymap entry. EVIOCGKEYCODE will also return scancode or index + * (depending on which element was used to perform lookup). + */ +struct input_keymap_entry { +#define INPUT_KEYMAP_BY_INDEX (1 << 0) + uint8_t flags; + uint8_t len; + uint16_t index; + uint32_t keycode; + uint8_t scancode[32]; +}; + +#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, unsigned int[2]) /* get repeat settings */ +#define EVIOCSREP _IOW('E', 0x03, unsigned int[2]) /* set repeat settings */ + +#define EVIOCGKEYCODE _IOR('E', 0x04, unsigned int[2]) /* get keycode */ +#define EVIOCGKEYCODE_V2 _IOR('E', 0x04, struct input_keymap_entry) +#define EVIOCSKEYCODE _IOW('E', 0x04, unsigned int[2]) /* set keycode */ +#define EVIOCSKEYCODE_V2 _IOW('E', 0x04, struct input_keymap_entry) + +#define EVIOCGNAME(len) _IOC(IOC_OUT, 'E', 0x06, len) /* get device name */ +#define EVIOCGPHYS(len) _IOC(IOC_OUT, 'E', 0x07, len) /* get physical location */ +#define EVIOCGUNIQ(len) _IOC(IOC_OUT, 'E', 0x08, len) /* get unique identifier */ +#define EVIOCGPROP(len) _IOC(IOC_OUT, 'E', 0x09, len) /* get device properties */ + +/** + * EVIOCGMTSLOTS(len) - get MT slot values + * @len: size of the data buffer in bytes + * + * The ioctl buffer argument should be binary equivalent to + * + * struct input_mt_request_layout { + * uint32_t code; + * int32_t values[num_slots]; + * }; + * + * where num_slots is the (arbitrary) number of MT slots to extract. + * + * The ioctl size argument (len) is the size of the buffer, which + * should satisfy len = (num_slots + 1) * sizeof(int32_t). If len is + * too small to fit all available slots, the first num_slots are + * returned. + * + * Before the call, code is set to the wanted ABS_MT event type. On + * return, values[] is filled with the slot values for the specified + * ABS_MT code. + * + * If the request code is not an ABS_MT value, -EINVAL is returned. + */ +#define EVIOCGMTSLOTS(len) _IOC(IOC_INOUT, 'E', 0x0a, len) + +#define EVIOCGKEY(len) _IOC(IOC_OUT, 'E', 0x18, len) /* get global key state */ +#define EVIOCGLED(len) _IOC(IOC_OUT, 'E', 0x19, len) /* get all LEDs */ +#define EVIOCGSND(len) _IOC(IOC_OUT, 'E', 0x1a, len) /* get all sounds status */ +#define EVIOCGSW(len) _IOC(IOC_OUT, 'E', 0x1b, len) /* get all switch states */ + +#define EVIOCGBIT(ev,len) _IOC(IOC_OUT, '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_IN, '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 _IOWINT('E', 0x90) /* Grab/Release device */ +#define EVIOCREVOKE _IOWINT('E', 0x91) /* Revoke device access */ + +#define EVIOCSCLOCKID _IOW('E', 0xa0, int) /* Set clockid to be used for timestamps */ + +/* + * Device properties and quirks + */ + +#define INPUT_PROP_POINTER 0x00 /* needs a pointer */ +#define INPUT_PROP_DIRECT 0x01 /* direct input devices */ +#define INPUT_PROP_BUTTONPAD 0x02 /* has button(s) under pad */ +#define INPUT_PROP_SEMI_MT 0x03 /* touch rectangle only */ +#define INPUT_PROP_TOPBUTTONPAD 0x04 /* softbuttons at top of pad */ +#define INPUT_PROP_POINTING_STICK 0x05 /* is a pointing stick */ +#define INPUT_PROP_ACCELEROMETER 0x06 /* has accelerometer */ + +#define INPUT_PROP_MAX 0x1f +#define INPUT_PROP_CNT (INPUT_PROP_MAX + 1) + +/* + * 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 +#define EV_CNT (EV_MAX+1) + +/* + * Synchronization events. + */ + +#define SYN_REPORT 0 +#define SYN_CONFIG 1 +#define SYN_MT_REPORT 2 +#define SYN_DROPPED 3 +#define SYN_MAX 0xf +#define SYN_CNT (SYN_MAX+1) + +/* + * Keys and buttons + * + * Most of the keys/buttons are modeled after USB HUT 1.12 + * (see http://www.usb.org/developers/hidpage). + * Abbreviations in the comments: + * AC - Application Control + * AL - Application Launch Button + * SC - System Control + */ + +#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 /* SC System Power Down */ +#define KEY_KPEQUAL 117 +#define KEY_KPPLUSMINUS 118 +#define KEY_PAUSE 119 +#define KEY_SCALE 120 /* AL Compiz Scale (Expose) */ + +#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 /* AC Stop */ +#define KEY_AGAIN 129 +#define KEY_PROPS 130 /* AC Properties */ +#define KEY_UNDO 131 /* AC Undo */ +#define KEY_FRONT 132 +#define KEY_COPY 133 /* AC Copy */ +#define KEY_OPEN 134 /* AC Open */ +#define KEY_PASTE 135 /* AC Paste */ +#define KEY_FIND 136 /* AC Search */ +#define KEY_CUT 137 /* AC Cut */ +#define KEY_HELP 138 /* AL Integrated Help Center */ +#define KEY_MENU 139 /* Menu (show menu) */ +#define KEY_CALC 140 /* AL Calculator */ +#define KEY_SETUP 141 +#define KEY_SLEEP 142 /* SC System Sleep */ +#define KEY_WAKEUP 143 /* System Wake Up */ +#define KEY_FILE 144 /* AL Local Machine Browser */ +#define KEY_SENDFILE 145 +#define KEY_DELETEFILE 146 +#define KEY_XFER 147 +#define KEY_PROG1 148 +#define KEY_PROG2 149 +#define KEY_WWW 150 /* AL Internet Browser */ +#define KEY_MSDOS 151 +#define KEY_COFFEE 152 /* AL Terminal Lock/Screensaver */ +#define KEY_SCREENLOCK KEY_COFFEE +#define KEY_ROTATE_DISPLAY 153 /* Display orientation for e.g. tablets */ +#define KEY_DIRECTION KEY_ROTATE_DISPLAY +#define KEY_CYCLEWINDOWS 154 +#define KEY_MAIL 155 +#define KEY_BOOKMARKS 156 /* AC Bookmarks */ +#define KEY_COMPUTER 157 +#define KEY_BACK 158 /* AC Back */ +#define KEY_FORWARD 159 /* AC Forward */ +#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 /* Media Select Telephone */ +#define KEY_ISO 170 +#define KEY_CONFIG 171 /* AL Consumer Control Configuration */ +#define KEY_HOMEPAGE 172 /* AC Home */ +#define KEY_REFRESH 173 /* AC Refresh */ +#define KEY_EXIT 174 /* AC Exit */ +#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 /* AC New */ +#define KEY_REDO 182 /* AC Redo/Repeat */ + +#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_DASHBOARD 204 /* AL Dashboard */ +#define KEY_SUSPEND 205 +#define KEY_CLOSE 206 /* AC Close */ +#define KEY_PLAY 207 +#define KEY_FASTFORWARD 208 +#define KEY_BASSBOOST 209 +#define KEY_PRINT 210 /* AC Print */ +#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 /* AL Checkbook/Finance */ +#define KEY_SPORT 220 +#define KEY_SHOP 221 +#define KEY_ALTERASE 222 +#define KEY_CANCEL 223 /* AC Cancel */ +#define KEY_BRIGHTNESSDOWN 224 +#define KEY_BRIGHTNESSUP 225 +#define KEY_MEDIA 226 + +#define KEY_SWITCHVIDEOMODE 227 /* Cycle between available video + outputs (Monitor/LCD/TV-out/etc) */ +#define KEY_KBDILLUMTOGGLE 228 +#define KEY_KBDILLUMDOWN 229 +#define KEY_KBDILLUMUP 230 + +#define KEY_SEND 231 /* AC Send */ +#define KEY_REPLY 232 /* AC Reply */ +#define KEY_FORWARDMAIL 233 /* AC Forward Msg */ +#define KEY_SAVE 234 /* AC Save */ +#define KEY_DOCUMENTS 235 + +#define KEY_BATTERY 236 + +#define KEY_BLUETOOTH 237 +#define KEY_WLAN 238 +#define KEY_UWB 239 + +#define KEY_UNKNOWN 240 + +#define KEY_VIDEO_NEXT 241 /* drive next video source */ +#define KEY_VIDEO_PREV 242 /* drive previous video source */ +#define KEY_BRIGHTNESS_CYCLE 243 /* brightness up, after max is min */ +#define KEY_BRIGHTNESS_AUTO 244 /* Set Auto Brightness: manual + brightness control is off, + rely on ambient */ +#define KEY_BRIGHTNESS_ZERO KEY_BRIGHTNESS_AUTO +#define KEY_DISPLAY_OFF 245 /* display device to off state */ + +#define KEY_WWAN 246 /* Wireless WAN (LTE, UMTS, GSM, etc.) */ +#define KEY_WIMAX KEY_WWAN +#define KEY_RFKILL 247 /* Key that controls all radios */ + +#define KEY_MICMUTE 248 /* Mute / unmute the microphone */ + +/* Code 255 is reserved for special needs of AT keyboard driver */ + +#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_SOUTH 0x130 +#define BTN_A BTN_SOUTH +#define BTN_EAST 0x131 +#define BTN_B BTN_EAST +#define BTN_C 0x132 +#define BTN_NORTH 0x133 +#define BTN_X BTN_NORTH +#define BTN_WEST 0x134 +#define BTN_Y BTN_WEST +#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_TOOL_QUINTTAP 0x148 /* Five fingers on trackpad */ +#define BTN_TOUCH 0x14a +#define BTN_STYLUS 0x14b +#define BTN_STYLUS2 0x14c +#define BTN_TOOL_DOUBLETAP 0x14d +#define BTN_TOOL_TRIPLETAP 0x14e +#define BTN_TOOL_QUADTAP 0x14f /* Four fingers on trackpad */ + +#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 /* AL OEM Features/Tips/Tutorial */ +#define KEY_TIME 0x167 +#define KEY_VENDOR 0x168 +#define KEY_ARCHIVE 0x169 +#define KEY_PROGRAM 0x16a /* Media Select Program Guide */ +#define KEY_CHANNEL 0x16b +#define KEY_FAVORITES 0x16c +#define KEY_EPG 0x16d +#define KEY_PVR 0x16e /* Media Select Home */ +#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 /* Media Select Computer */ +#define KEY_TV 0x179 /* Media Select TV */ +#define KEY_TV2 0x17a /* Media Select Cable */ +#define KEY_VCR 0x17b /* Media Select VCR */ +#define KEY_VCR2 0x17c /* VCR Plus */ +#define KEY_SAT 0x17d /* Media Select Satellite */ +#define KEY_SAT2 0x17e +#define KEY_CD 0x17f /* Media Select CD */ +#define KEY_TAPE 0x180 /* Media Select Tape */ +#define KEY_RADIO 0x181 +#define KEY_TUNER 0x182 /* Media Select Tuner */ +#define KEY_PLAYER 0x183 +#define KEY_TEXT 0x184 +#define KEY_DVD 0x185 /* Media Select DVD */ +#define KEY_AUX 0x186 +#define KEY_MP3 0x187 +#define KEY_AUDIO 0x188 /* AL Audio Browser */ +#define KEY_VIDEO 0x189 /* AL Movie Browser */ +#define KEY_DIRECTORY 0x18a +#define KEY_LIST 0x18b +#define KEY_MEMO 0x18c /* Media Select Messages */ +#define KEY_CALENDAR 0x18d +#define KEY_RED 0x18e +#define KEY_GREEN 0x18f +#define KEY_YELLOW 0x190 +#define KEY_BLUE 0x191 +#define KEY_CHANNELUP 0x192 /* Channel Increment */ +#define KEY_CHANNELDOWN 0x193 /* Channel Decrement */ +#define KEY_FIRST 0x194 +#define KEY_LAST 0x195 /* Recall Last */ +#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 /* Media Select Video Phone */ +#define KEY_GAMES 0x1a1 /* Media Select Games */ +#define KEY_ZOOMIN 0x1a2 /* AC Zoom In */ +#define KEY_ZOOMOUT 0x1a3 /* AC Zoom Out */ +#define KEY_ZOOMRESET 0x1a4 /* AC Zoom */ +#define KEY_WORDPROCESSOR 0x1a5 /* AL Word Processor */ +#define KEY_EDITOR 0x1a6 /* AL Text Editor */ +#define KEY_SPREADSHEET 0x1a7 /* AL Spreadsheet */ +#define KEY_GRAPHICSEDITOR 0x1a8 /* AL Graphics Editor */ +#define KEY_PRESENTATION 0x1a9 /* AL Presentation App */ +#define KEY_DATABASE 0x1aa /* AL Database App */ +#define KEY_NEWS 0x1ab /* AL Newsreader */ +#define KEY_VOICEMAIL 0x1ac /* AL Voicemail */ +#define KEY_ADDRESSBOOK 0x1ad /* AL Contacts/Address Book */ +#define KEY_MESSENGER 0x1ae /* AL Instant Messaging */ +#define KEY_DISPLAYTOGGLE 0x1af /* Turn display (LCD) on and off */ +#define KEY_BRIGHTNESS_TOGGLE KEY_DISPLAYTOGGLE +#define KEY_SPELLCHECK 0x1b0 /* AL Spell Check */ +#define KEY_LOGOFF 0x1b1 /* AL Logoff */ + +#define KEY_DOLLAR 0x1b2 +#define KEY_EURO 0x1b3 + +#define KEY_FRAMEBACK 0x1b4 /* Consumer - transport controls */ +#define KEY_FRAMEFORWARD 0x1b5 +#define KEY_CONTEXT_MENU 0x1b6 /* GenDesc - system context menu */ +#define KEY_MEDIA_REPEAT 0x1b7 /* Consumer - transport control */ +#define KEY_10CHANNELSUP 0x1b8 /* 10 channels up (10+) */ +#define KEY_10CHANNELSDOWN 0x1b9 /* 10 channels down (10-) */ +#define KEY_IMAGES 0x1ba /* AL Image Browser */ + +#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 +#define KEY_BRL_DOT9 0x1f9 +#define KEY_BRL_DOT10 0x1fa + +#define KEY_NUMERIC_0 0x200 /* used by phones, remote controls, */ +#define KEY_NUMERIC_1 0x201 /* and other keypads */ +#define KEY_NUMERIC_2 0x202 +#define KEY_NUMERIC_3 0x203 +#define KEY_NUMERIC_4 0x204 +#define KEY_NUMERIC_5 0x205 +#define KEY_NUMERIC_6 0x206 +#define KEY_NUMERIC_7 0x207 +#define KEY_NUMERIC_8 0x208 +#define KEY_NUMERIC_9 0x209 +#define KEY_NUMERIC_STAR 0x20a +#define KEY_NUMERIC_POUND 0x20b +#define KEY_NUMERIC_A 0x20c /* Phone key A - HUT Telephony 0xb9 */ +#define KEY_NUMERIC_B 0x20d +#define KEY_NUMERIC_C 0x20e +#define KEY_NUMERIC_D 0x20f + +#define KEY_CAMERA_FOCUS 0x210 +#define KEY_WPS_BUTTON 0x211 /* WiFi Protected Setup key */ + +#define KEY_TOUCHPAD_TOGGLE 0x212 /* Request switch touchpad on or off */ +#define KEY_TOUCHPAD_ON 0x213 +#define KEY_TOUCHPAD_OFF 0x214 + +#define KEY_CAMERA_ZOOMIN 0x215 +#define KEY_CAMERA_ZOOMOUT 0x216 +#define KEY_CAMERA_UP 0x217 +#define KEY_CAMERA_DOWN 0x218 +#define KEY_CAMERA_LEFT 0x219 +#define KEY_CAMERA_RIGHT 0x21a + +#define KEY_ATTENDANT_ON 0x21b +#define KEY_ATTENDANT_OFF 0x21c +#define KEY_ATTENDANT_TOGGLE 0x21d /* Attendant call on or off */ +#define KEY_LIGHTS_TOGGLE 0x21e /* Reading light on or off */ + +#define BTN_DPAD_UP 0x220 +#define BTN_DPAD_DOWN 0x221 +#define BTN_DPAD_LEFT 0x222 +#define BTN_DPAD_RIGHT 0x223 + +#define KEY_ALS_TOGGLE 0x230 /* Ambient light sensor */ + +#define KEY_BUTTONCONFIG 0x240 /* AL Button Configuration */ +#define KEY_TASKMANAGER 0x241 /* AL Task/Project Manager */ +#define KEY_JOURNAL 0x242 /* AL Log/Journal/Timecard */ +#define KEY_CONTROLPANEL 0x243 /* AL Control Panel */ +#define KEY_APPSELECT 0x244 /* AL Select Task/Application */ +#define KEY_SCREENSAVER 0x245 /* AL Screen Saver */ +#define KEY_VOICECOMMAND 0x246 /* Listening Voice Command */ + +#define KEY_BRIGHTNESS_MIN 0x250 /* Set Brightness to Minimum */ +#define KEY_BRIGHTNESS_MAX 0x251 /* Set Brightness to Maximum */ + +#define KEY_KBDINPUTASSIST_PREV 0x260 +#define KEY_KBDINPUTASSIST_NEXT 0x261 +#define KEY_KBDINPUTASSIST_PREVGROUP 0x262 +#define KEY_KBDINPUTASSIST_NEXTGROUP 0x263 +#define KEY_KBDINPUTASSIST_ACCEPT 0x264 +#define KEY_KBDINPUTASSIST_CANCEL 0x265 + +#define BTN_TRIGGER_HAPPY 0x2c0 +#define BTN_TRIGGER_HAPPY1 0x2c0 +#define BTN_TRIGGER_HAPPY2 0x2c1 +#define BTN_TRIGGER_HAPPY3 0x2c2 +#define BTN_TRIGGER_HAPPY4 0x2c3 +#define BTN_TRIGGER_HAPPY5 0x2c4 +#define BTN_TRIGGER_HAPPY6 0x2c5 +#define BTN_TRIGGER_HAPPY7 0x2c6 +#define BTN_TRIGGER_HAPPY8 0x2c7 +#define BTN_TRIGGER_HAPPY9 0x2c8 +#define BTN_TRIGGER_HAPPY10 0x2c9 +#define BTN_TRIGGER_HAPPY11 0x2ca +#define BTN_TRIGGER_HAPPY12 0x2cb +#define BTN_TRIGGER_HAPPY13 0x2cc +#define BTN_TRIGGER_HAPPY14 0x2cd +#define BTN_TRIGGER_HAPPY15 0x2ce +#define BTN_TRIGGER_HAPPY16 0x2cf +#define BTN_TRIGGER_HAPPY17 0x2d0 +#define BTN_TRIGGER_HAPPY18 0x2d1 +#define BTN_TRIGGER_HAPPY19 0x2d2 +#define BTN_TRIGGER_HAPPY20 0x2d3 +#define BTN_TRIGGER_HAPPY21 0x2d4 +#define BTN_TRIGGER_HAPPY22 0x2d5 +#define BTN_TRIGGER_HAPPY23 0x2d6 +#define BTN_TRIGGER_HAPPY24 0x2d7 +#define BTN_TRIGGER_HAPPY25 0x2d8 +#define BTN_TRIGGER_HAPPY26 0x2d9 +#define BTN_TRIGGER_HAPPY27 0x2da +#define BTN_TRIGGER_HAPPY28 0x2db +#define BTN_TRIGGER_HAPPY29 0x2dc +#define BTN_TRIGGER_HAPPY30 0x2dd +#define BTN_TRIGGER_HAPPY31 0x2de +#define BTN_TRIGGER_HAPPY32 0x2df +#define BTN_TRIGGER_HAPPY33 0x2e0 +#define BTN_TRIGGER_HAPPY34 0x2e1 +#define BTN_TRIGGER_HAPPY35 0x2e2 +#define BTN_TRIGGER_HAPPY36 0x2e3 +#define BTN_TRIGGER_HAPPY37 0x2e4 +#define BTN_TRIGGER_HAPPY38 0x2e5 +#define BTN_TRIGGER_HAPPY39 0x2e6 +#define BTN_TRIGGER_HAPPY40 0x2e7 + +/* We avoid low common keys in module aliases so they don't get huge. */ +#define KEY_MIN_INTERESTING KEY_MUTE +#define KEY_MAX 0x2ff +#define KEY_CNT (KEY_MAX+1) + +/* + * 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 +#define REL_CNT (REL_MAX+1) + +/* + * 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_MT_SLOT 0x2f /* MT slot being modified */ +#define ABS_MT_TOUCH_MAJOR 0x30 /* Major axis of touching ellipse */ +#define ABS_MT_TOUCH_MINOR 0x31 /* Minor axis (omit if circular) */ +#define ABS_MT_WIDTH_MAJOR 0x32 /* Major axis of approaching ellipse */ +#define ABS_MT_WIDTH_MINOR 0x33 /* Minor axis (omit if circular) */ +#define ABS_MT_ORIENTATION 0x34 /* Ellipse orientation */ +#define ABS_MT_POSITION_X 0x35 /* Center X touch position */ +#define ABS_MT_POSITION_Y 0x36 /* Center Y touch position */ +#define ABS_MT_TOOL_TYPE 0x37 /* Type of touching device */ +#define ABS_MT_BLOB_ID 0x38 /* Group a set of packets as a blob */ +#define ABS_MT_TRACKING_ID 0x39 /* Unique ID of initiated contact */ +#define ABS_MT_PRESSURE 0x3a /* Pressure on contact area */ +#define ABS_MT_DISTANCE 0x3b /* Contact hover distance */ +#define ABS_MT_TOOL_X 0x3c /* Center X tool position */ +#define ABS_MT_TOOL_Y 0x3d /* Center Y tool position */ + + +#define ABS_MAX 0x3f +#define ABS_CNT (ABS_MAX+1) + +/* + * 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_RFKILL_ALL 0x03 /* rfkill master switch, type "any" + set = radio enabled */ +#define SW_RADIO SW_RFKILL_ALL /* deprecated */ +#define SW_MICROPHONE_INSERT 0x04 /* set = inserted */ +#define SW_DOCK 0x05 /* set = plugged into dock */ +#define SW_LINEOUT_INSERT 0x06 /* set = inserted */ +#define SW_JACK_PHYSICAL_INSERT 0x07 /* set = mechanical switch set */ +#define SW_VIDEOOUT_INSERT 0x08 /* set = inserted */ +#define SW_CAMERA_LENS_COVER 0x09 /* set = lens covered */ +#define SW_KEYPAD_SLIDE 0x0a /* set = keypad slide out */ +#define SW_FRONT_PROXIMITY 0x0b /* set = front proximity sensor active */ +#define SW_ROTATE_LOCK 0x0c /* set = rotate locked/disabled */ +#define SW_LINEIN_INSERT 0x0d /* set = inserted */ +#define SW_MUTE_DEVICE 0x0e /* set = device disabled */ +#define SW_MAX 0x0f +#define SW_CNT (SW_MAX+1) + +/* + * Misc events + */ + +#define MSC_SERIAL 0x00 +#define MSC_PULSELED 0x01 +#define MSC_GESTURE 0x02 +#define MSC_RAW 0x03 +#define MSC_SCAN 0x04 +#define MSC_TIMESTAMP 0x05 +#define MSC_MAX 0x07 +#define MSC_CNT (MSC_MAX+1) + +/* + * 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 +#define LED_CNT (LED_MAX+1) + +/* + * Autorepeat values + */ + +#define REP_DELAY 0x00 +#define REP_PERIOD 0x01 +#define REP_MAX 0x01 +#define REP_CNT (REP_MAX+1) + +/* + * Sounds + */ + +#define SND_CLICK 0x00 +#define SND_BELL 0x01 +#define SND_TONE 0x02 +#define SND_MAX 0x07 +#define SND_CNT (SND_MAX+1) + +/* + * 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 +#define BUS_ATARI 0x1B +#define BUS_SPI 0x1C + +/* + * MT_TOOL types + */ +#define MT_TOOL_FINGER 0 +#define MT_TOOL_PEN 1 +#define MT_TOOL_PALM 2 +#define MT_TOOL_MAX 2 + +/* + * 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 { + uint16_t length; + uint16_t 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 { + uint16_t button; + uint16_t 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 { + uint16_t attack_length; + uint16_t attack_level; + uint16_t fade_length; + uint16_t 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 { + int16_t 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 { + int16_t start_level; + int16_t 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 { + uint16_t right_saturation; + uint16_t left_saturation; + + int16_t right_coeff; + int16_t left_coeff; + + uint16_t deadband; + int16_t 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 { + uint16_t waveform; + uint16_t period; + int16_t magnitude; + int16_t offset; + uint16_t phase; + + struct ff_envelope envelope; + + uint32_t custom_len; + int16_t *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 { + uint16_t strong_magnitude; + uint16_t 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 application 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 { + uint16_t type; + int16_t id; + uint16_t 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 +#define FF_CNT (FF_MAX+1) + +#endif /* _UAPI_INPUT_H */ diff --git a/sys/dev/evdev/uinput.c b/sys/dev/evdev/uinput.c new file mode 100644 index 0000000..3eb21131 --- /dev/null +++ b/sys/dev/evdev/uinput.c @@ -0,0 +1,358 @@ +/*- + * Copyright (c) 2014 Jakub Wojciech Klama + * All rights reserved. + * + * 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. + * + * $FreeBSD$ + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#define DEBUG +#ifdef DEBUG +#define debugf(fmt, args...) printf("evdev: " fmt "\n", ##args); +#else +#define debugf(fmt, args...) +#endif + +static int uinput_open(struct cdev *, int, int, struct thread *); +static int uinput_close(struct cdev *, int, int, struct thread *); +static int uinput_read(struct cdev *, struct uio *, int); +static int uinput_write(struct cdev *, struct uio *, int); +static int uinput_ioctl(struct cdev *, u_long, caddr_t, int, struct thread *); +static int uinput_poll(struct cdev *, int, struct thread *); +static void uinput_dtor(void *); + +static int uinput_setup_provider(struct evdev_dev *, struct uinput_user_dev *); +static int uinput_cdev_create(void); + +static struct cdevsw uinput_cdevsw = { + .d_version = D_VERSION, + .d_open = uinput_open, + .d_close = uinput_close, + .d_read = uinput_read, + .d_write = uinput_write, + .d_ioctl = uinput_ioctl, + .d_poll = uinput_poll, + .d_name = "uinput", + .d_flags = D_TRACKCLOSE, +}; + +static struct evdev_methods uinput_ev_methods = { + .ev_open = NULL, + .ev_close = NULL, +}; + +struct uinput_cdev_softc +{ + int ucs_open_count; + + LIST_ENTRY(uinput_cdev_softc) ucs_link; +}; + +struct uinput_cdev_state +{ + bool ucs_connected; + struct evdev_dev * ucs_evdev; + struct mtx ucs_mtx; +}; + +static int +uinput_open(struct cdev *dev, int oflags, int devtype, struct thread *td) +{ + struct uinput_cdev_state *state; + + state = malloc(sizeof(struct uinput_cdev_state), M_EVDEV, M_WAITOK | M_ZERO); + state->ucs_evdev = evdev_alloc(); + + devfs_set_cdevpriv(state, uinput_dtor); + return (0); +} + +static int +uinput_close(struct cdev *dev, int fflag, int devtype, struct thread *td) +{ + struct uinput_cdev_softc *sc = dev->si_drv1; + + sc->ucs_open_count--; + return (0); +} + +static void +uinput_dtor(void *data) +{ + struct uinput_cdev_state *state = (struct uinput_cdev_state *)data; + + if (state->ucs_connected) + evdev_unregister(NULL, state->ucs_evdev); + + evdev_free(state->ucs_evdev); + free(data, M_EVDEV); +} + +static int +uinput_read(struct cdev *dev, struct uio *uio, int ioflag) +{ + struct uinput_cdev_state *state; + struct evdev_dev *evdev; + int ret = 0; + + debugf("uinput: read %zd bytes by thread %d", uio->uio_resid, + uio->uio_td->td_tid); + + ret = devfs_get_cdevpriv((void **)&state); + if (ret != 0) + return (ret); + + evdev = state->ucs_evdev; + + if (uio->uio_resid % sizeof(struct input_event) != 0) { + debugf("read size not multiple of struct input_event size"); + return (EINVAL); + } + + return (0); +} + +static int +uinput_write(struct cdev *dev, struct uio *uio, int ioflag) +{ + struct uinput_cdev_state *state; + struct uinput_user_dev userdev; + struct input_event event; + int ret = 0; + + debugf("uinput: write %zd bytes by thread %d", uio->uio_resid, + uio->uio_td->td_tid); + + ret = devfs_get_cdevpriv((void **)&state); + if (ret != 0) + return (ret); + + if (!state->ucs_connected) { + /* Process written struct uinput_user_dev */ + if (uio->uio_resid != sizeof(struct uinput_user_dev)) { + debugf("write size not multiple of struct uinput_user_dev size"); + return (EINVAL); + } + + uiomove(&userdev, sizeof(struct uinput_user_dev), uio); + uinput_setup_provider(state->ucs_evdev, &userdev); + } else { + /* Process written event */ + if (uio->uio_resid % sizeof(struct input_event) != 0) { + debugf("write size not multiple of struct input_event size"); + return (EINVAL); + } + + while (uio->uio_resid > 0) { + uiomove(&event, sizeof(struct input_event), uio); + ret = evdev_push_event(state->ucs_evdev, event.type, event.code, + event.value); + + if (ret != 0) + return (ret); + } + } + + return (0); +} + +static int +uinput_setup_provider(struct evdev_dev *evdev, struct uinput_user_dev *udev) +{ + struct input_absinfo absinfo; + int i; + + debugf("uinput: setup_provider called, udev=%p", udev); + + evdev_set_name(evdev, udev->name); + memcpy(&evdev->ev_id, &udev->id, sizeof(struct input_id)); + + bzero(&absinfo, sizeof(struct input_absinfo)); + for (i = 0; i < ABS_CNT; i++) { + if (!isset(&evdev->ev_abs_flags, i)) + continue; + + absinfo.minimum = udev->absmin[i]; + absinfo.maximum = udev->absmax[i]; + absinfo.fuzz = udev->absfuzz[i]; + absinfo.flat = udev->absflat[i]; + evdev_set_absinfo(evdev, i, &absinfo); + } + + return (0); +} + +static int +uinput_poll(struct cdev *dev, int events, struct thread *td) +{ + int revents = 0; + + /* Always allow write */ + if (events & (POLLOUT | POLLWRNORM)) + revents |= (events & (POLLOUT | POLLWRNORM)); + + return (revents); +} + +static int +uinput_ioctl(struct cdev *dev, u_long cmd, caddr_t data, int fflag, + struct thread *td) +{ + struct uinput_cdev_state *state; + int ret, len; + char buf[NAMELEN]; + + len = IOCPARM_LEN(cmd); + + debugf("uinput: ioctl called: cmd=0x%08lx, data=%p", cmd, data); + + ret = devfs_get_cdevpriv((void **)&state); + if (ret != 0) + return (ret); + + switch (IOCBASECMD(cmd)) { + case UI_GET_SYSNAME(0): + if (!state->ucs_connected) + return (ENOENT); + if (len == 0) + return (EINVAL); + snprintf(data, len, "event%d", state->ucs_evdev->ev_unit); + return (0); + } + + switch (cmd) { + case UI_DEV_CREATE: + evdev_set_methods(state->ucs_evdev, &uinput_ev_methods); + evdev_set_softc(state->ucs_evdev, state); + evdev_register(NULL, state->ucs_evdev); + state->ucs_connected = true; + return (0); + + case UI_DEV_DESTROY: + if (!state->ucs_connected) + return (0); + + evdev_unregister(NULL, state->ucs_evdev); + state->ucs_connected = false; + return (0); + + case UI_SET_EVBIT: + if (*(int *)data == EV_REP) + return (evdev_support_repeat(state->ucs_evdev, + EV_EVDEV_REPEAT)); + else + return (evdev_support_event(state->ucs_evdev, + *(int *)data)); + + case UI_SET_KEYBIT: + return (evdev_support_key(state->ucs_evdev, *(int *)data)); + + case UI_SET_RELBIT: + return (evdev_support_rel(state->ucs_evdev, *(int *)data)); + + case UI_SET_ABSBIT: + return (evdev_support_abs(state->ucs_evdev, *(int *)data)); + + case UI_SET_MSCBIT: + return (evdev_support_msc(state->ucs_evdev, *(int *)data)); + + case UI_SET_LEDBIT: + return (evdev_support_led(state->ucs_evdev, *(int *)data)); + + case UI_SET_SNDBIT: + return (evdev_support_snd(state->ucs_evdev, *(int *)data)); + + case UI_SET_FFBIT: + /* Fake unsupported ioctl */ + return (0); + + case UI_SET_PHYS: + if (state->ucs_connected) + return (EINVAL); + ret = copyinstr(*(void **)data, buf, sizeof(buf), NULL); + /* Linux returns EINVAL when string does not fit the buffer */ + if (ret == ENAMETOOLONG) + ret = EINVAL; + if (ret != 0) + return (ret); + evdev_set_phys(state->ucs_evdev, buf); + return (0); + + case UI_SET_SWBIT: + return (evdev_support_sw(state->ucs_evdev, *(int *)data)); + + case UI_SET_PROPBIT: + return (evdev_support_prop(state->ucs_evdev, *(int *)data)); + + case UI_BEGIN_FF_UPLOAD: + case UI_END_FF_UPLOAD: + case UI_BEGIN_FF_ERASE: + case UI_END_FF_ERASE: + /* Fake unsupported ioctl */ + return (0); + + case UI_GET_VERSION: + *(unsigned int *)data = UINPUT_VERSION; + return (0); + } + + return (EINVAL); +} + +static int +uinput_cdev_create(void) +{ + struct uinput_cdev_softc *sc; + struct make_dev_args mda; + struct cdev *cdev; + + sc = malloc(sizeof(struct uinput_cdev_softc), M_EVDEV, M_WAITOK | M_ZERO); + + make_dev_args_init(&mda); + mda.mda_devsw = &uinput_cdevsw; + mda.mda_uid = UID_ROOT; + mda.mda_gid = GID_WHEEL; + mda.mda_mode = 0600; + mda.mda_si_drv1 = sc; + + make_dev_s(&mda, &cdev, "uinput"); + + return (0); +} + +SYSINIT(uinput, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, uinput_cdev_create, NULL); diff --git a/sys/dev/evdev/uinput.h b/sys/dev/evdev/uinput.h new file mode 100644 index 0000000..523122c --- /dev/null +++ b/sys/dev/evdev/uinput.h @@ -0,0 +1,157 @@ +/* + * User level driver support for input subsystem + * + * Heavily based on evdev.c by Vojtech Pavlik + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Author: Aristeu Sergio Rozanski Filho + * + * Changes/Revisions: + * 0.4 01/09/2014 (Benjamin Tissoires ) + * - add UI_GET_SYSNAME ioctl + * 0.3 24/05/2006 (Anssi Hannula ) + * - update ff support for the changes in kernel interface + * - add UINPUT_VERSION + * 0.2 16/10/2004 (Micah Dowty ) + * - added force feedback support + * - added UI_SET_PHYS + * 0.1 20/06/2002 + * - first public version + */ +#ifndef _UAPI__UINPUT_H_ +#define _UAPI__UINPUT_H_ + +#include +#include + +#define UINPUT_VERSION 4 + + +struct uinput_ff_upload { + uint32_t request_id; + int32_t retval; + struct ff_effect effect; + struct ff_effect old; +}; + +struct uinput_ff_erase { + uint32_t request_id; + int32_t retval; + uint32_t effect_id; +}; + +/* ioctl */ +#define UINPUT_IOCTL_BASE 'U' +#define UI_DEV_CREATE _IO(UINPUT_IOCTL_BASE, 1) +#define UI_DEV_DESTROY _IO(UINPUT_IOCTL_BASE, 2) + +#define UI_SET_EVBIT _IOWINT(UINPUT_IOCTL_BASE, 100) +#define UI_SET_KEYBIT _IOWINT(UINPUT_IOCTL_BASE, 101) +#define UI_SET_RELBIT _IOWINT(UINPUT_IOCTL_BASE, 102) +#define UI_SET_ABSBIT _IOWINT(UINPUT_IOCTL_BASE, 103) +#define UI_SET_MSCBIT _IOWINT(UINPUT_IOCTL_BASE, 104) +#define UI_SET_LEDBIT _IOWINT(UINPUT_IOCTL_BASE, 105) +#define UI_SET_SNDBIT _IOWINT(UINPUT_IOCTL_BASE, 106) +#define UI_SET_FFBIT _IOWINT(UINPUT_IOCTL_BASE, 107) +#define UI_SET_PHYS _IO(UINPUT_IOCTL_BASE, 108) +#define UI_SET_SWBIT _IOWINT(UINPUT_IOCTL_BASE, 109) +#define UI_SET_PROPBIT _IOWINT(UINPUT_IOCTL_BASE, 110) + +#define UI_BEGIN_FF_UPLOAD _IOWR(UINPUT_IOCTL_BASE, 200, struct uinput_ff_upload) +#define UI_END_FF_UPLOAD _IOW(UINPUT_IOCTL_BASE, 201, struct uinput_ff_upload) +#define UI_BEGIN_FF_ERASE _IOWR(UINPUT_IOCTL_BASE, 202, struct uinput_ff_erase) +#define UI_END_FF_ERASE _IOW(UINPUT_IOCTL_BASE, 203, struct uinput_ff_erase) + +/** + * UI_GET_SYSNAME - get the devfs name of the created uinput device + * + * @return the devfs name of the created virtual input device. + * The complete devfs path is then /dev/input/--NAME-- + * Usually, it is in the form "eventN" + */ +#define UI_GET_SYSNAME(len) _IOC(IOC_OUT, UINPUT_IOCTL_BASE, 44, len) + +/** + * UI_GET_VERSION - Return version of uinput protocol + * + * This writes uinput protocol version implemented by the kernel into + * the integer pointed to by the ioctl argument. The protocol version + * is hard-coded in the kernel and is independent of the uinput device. + */ +#define UI_GET_VERSION _IOR(UINPUT_IOCTL_BASE, 45, unsigned int) + +/* + * To write a force-feedback-capable driver, the upload_effect + * and erase_effect callbacks in input_dev must be implemented. + * The uinput driver will generate a fake input event when one of + * these callbacks are invoked. The userspace code then uses + * ioctls to retrieve additional parameters and send the return code. + * The callback blocks until this return code is sent. + * + * The described callback mechanism is only used if ff_effects_max + * is set. + * + * To implement upload_effect(): + * 1. Wait for an event with type == EV_UINPUT and code == UI_FF_UPLOAD. + * A request ID will be given in 'value'. + * 2. Allocate a uinput_ff_upload struct, fill in request_id with + * the 'value' from the EV_UINPUT event. + * 3. Issue a UI_BEGIN_FF_UPLOAD ioctl, giving it the + * uinput_ff_upload struct. It will be filled in with the + * ff_effects passed to upload_effect(). + * 4. Perform the effect upload, and place a return code back into + the uinput_ff_upload struct. + * 5. Issue a UI_END_FF_UPLOAD ioctl, also giving it the + * uinput_ff_upload_effect struct. This will complete execution + * of our upload_effect() handler. + * + * To implement erase_effect(): + * 1. Wait for an event with type == EV_UINPUT and code == UI_FF_ERASE. + * A request ID will be given in 'value'. + * 2. Allocate a uinput_ff_erase struct, fill in request_id with + * the 'value' from the EV_UINPUT event. + * 3. Issue a UI_BEGIN_FF_ERASE ioctl, giving it the + * uinput_ff_erase struct. It will be filled in with the + * effect ID passed to erase_effect(). + * 4. Perform the effect erasure, and place a return code back + * into the uinput_ff_erase struct. + * 5. Issue a UI_END_FF_ERASE ioctl, also giving it the + * uinput_ff_erase_effect struct. This will complete execution + * of our erase_effect() handler. + */ + +/* + * This is the new event type, used only by uinput. + * 'code' is UI_FF_UPLOAD or UI_FF_ERASE, and 'value' + * is the unique request ID. This number was picked + * arbitrarily, above EV_MAX (since the input system + * never sees it) but in the range of a 16-bit int. + */ +#define EV_UINPUT 0x0101 +#define UI_FF_UPLOAD 1 +#define UI_FF_ERASE 2 + +#define UINPUT_MAX_NAME_SIZE 80 +struct uinput_user_dev { + char name[UINPUT_MAX_NAME_SIZE]; + struct input_id id; + uint32_t ff_effects_max; + int32_t absmax[ABS_CNT]; + int32_t absmin[ABS_CNT]; + int32_t absfuzz[ABS_CNT]; + int32_t absflat[ABS_CNT]; +}; +#endif /* _UAPI__UINPUT_H_ */