293 lines
9.7 KiB
C
293 lines
9.7 KiB
C
/*-
|
|
* Copyright (c) 2014 Jakub Wojciech Klama <jceel@FreeBSD.org>
|
|
* Copyright (c) 2015-2016 Vladimir Kondratyev <wulf@FreeBSD.org>
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef _DEV_EVDEV_EVDEV_PRIVATE_H
|
|
#define _DEV_EVDEV_EVDEV_PRIVATE_H
|
|
|
|
#include <sys/bitstring.h>
|
|
#include <sys/ck.h>
|
|
#include <sys/epoch.h>
|
|
#include <sys/kbio.h>
|
|
#include <sys/lock.h>
|
|
#include <sys/malloc.h>
|
|
#include <sys/mutex.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/selinfo.h>
|
|
#include <sys/sx.h>
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <dev/evdev/evdev.h>
|
|
#include <dev/evdev/input.h>
|
|
#include <dev/kbd/kbdreg.h>
|
|
|
|
#define NAMELEN 80
|
|
|
|
/*
|
|
* bitstr_t implementation must be identical to one found in EVIOCG*
|
|
* libevdev ioctls. Our bitstring(3) API is compatible since r299090.
|
|
*/
|
|
_Static_assert(sizeof(bitstr_t) == sizeof(unsigned long),
|
|
"bitstr_t size mismatch");
|
|
|
|
MALLOC_DECLARE(M_EVDEV);
|
|
|
|
struct evdev_client;
|
|
struct evdev_mt;
|
|
|
|
#define CURRENT_MT_SLOT(evdev) ((evdev)->ev_absinfo[ABS_MT_SLOT].value)
|
|
#define MAXIMAL_MT_SLOT(evdev) ((evdev)->ev_absinfo[ABS_MT_SLOT].maximum)
|
|
|
|
enum evdev_key_events
|
|
{
|
|
KEY_EVENT_UP,
|
|
KEY_EVENT_DOWN,
|
|
KEY_EVENT_REPEAT
|
|
};
|
|
|
|
/* evdev clock IDs in Linux semantic */
|
|
enum evdev_clock_id
|
|
{
|
|
EV_CLOCK_REALTIME = 0, /* UTC clock */
|
|
EV_CLOCK_MONOTONIC, /* monotonic, stops on suspend */
|
|
EV_CLOCK_BOOTTIME /* monotonic, suspend-awared */
|
|
};
|
|
|
|
/*
|
|
* Locking.
|
|
*
|
|
* Internal evdev structures are protected with next locks:
|
|
* State lock (s) - Internal state. The data it protects is changed
|
|
* by incoming evdev events and some ioctls.
|
|
* Client list epoch (l) - Read access to client list.
|
|
* Client list lock (l) - Write access to client list.
|
|
* Client queue locks (q) - One lock per client to serialize access to data
|
|
* available through character device node.
|
|
*
|
|
* Depending on evdev_register_() suffix evdev can run in following modes:
|
|
* 1. Internal epoch. evdev_register(). All locks are internal.
|
|
* 2. External epoch. Evdev expects to be run under input epoch entered by
|
|
* parent driver. The mode is enabled with EVDEV_FLAG_EXT_EPOCH flag.
|
|
* 3. External mutex. evdev_register_mtx(). Evdev uses mutex provided by parent
|
|
* driver as both "State lock" and "Client list lock". This mode is
|
|
* deprecated as it causes ev_open and ev_close handlers to be called with
|
|
* parent driver mutex taken.
|
|
*/
|
|
#define INPUT_EPOCH global_epoch_preempt
|
|
|
|
enum evdev_lock_type
|
|
{
|
|
EV_LOCK_INTERNAL = 0, /* Internal epoch */
|
|
EV_LOCK_MTX, /* Driver`s mutex */
|
|
EV_LOCK_EXT_EPOCH, /* External epoch */
|
|
};
|
|
|
|
struct evdev_dev
|
|
{
|
|
char ev_name[NAMELEN];
|
|
char ev_shortname[NAMELEN];
|
|
char ev_serial[NAMELEN];
|
|
struct cdev * ev_cdev;
|
|
int ev_unit;
|
|
enum evdev_lock_type ev_lock_type;
|
|
struct mtx * ev_state_lock; /* State lock */
|
|
struct mtx ev_mtx; /* Internal state lock */
|
|
struct sx ev_list_lock; /* Client list lock */
|
|
struct input_id ev_id;
|
|
struct evdev_client * ev_grabber; /* (s) */
|
|
size_t ev_report_size;
|
|
|
|
/* Supported features: */
|
|
bitstr_t bit_decl(ev_prop_flags, INPUT_PROP_CNT);
|
|
bitstr_t bit_decl(ev_type_flags, EV_CNT);
|
|
bitstr_t bit_decl(ev_key_flags, KEY_CNT);
|
|
bitstr_t bit_decl(ev_rel_flags, REL_CNT);
|
|
bitstr_t bit_decl(ev_abs_flags, ABS_CNT);
|
|
bitstr_t bit_decl(ev_msc_flags, MSC_CNT);
|
|
bitstr_t bit_decl(ev_led_flags, LED_CNT);
|
|
bitstr_t bit_decl(ev_snd_flags, SND_CNT);
|
|
bitstr_t bit_decl(ev_sw_flags, SW_CNT);
|
|
struct input_absinfo * ev_absinfo; /* (s) */
|
|
bitstr_t bit_decl(ev_flags, EVDEV_FLAG_CNT);
|
|
|
|
/* Repeat parameters & callout: */
|
|
int ev_rep[REP_CNT]; /* (s) */
|
|
struct callout ev_rep_callout; /* (s) */
|
|
uint16_t ev_rep_key; /* (s) */
|
|
|
|
/* State: */
|
|
bitstr_t bit_decl(ev_key_states, KEY_CNT); /* (s) */
|
|
bitstr_t bit_decl(ev_led_states, LED_CNT); /* (s) */
|
|
bitstr_t bit_decl(ev_snd_states, SND_CNT); /* (s) */
|
|
bitstr_t bit_decl(ev_sw_states, SW_CNT); /* (s) */
|
|
bool ev_report_opened; /* (s) */
|
|
|
|
/* KDB state: */
|
|
bool ev_kdb_active;
|
|
bitstr_t bit_decl(ev_kdb_led_states, LED_CNT);
|
|
|
|
/* Multitouch protocol type B state: */
|
|
struct evdev_mt * ev_mt; /* (s) */
|
|
|
|
/* Counters: */
|
|
uint64_t ev_event_count; /* (s) */
|
|
uint64_t ev_report_count; /* (s) */
|
|
|
|
/* Parent driver callbacks: */
|
|
const struct evdev_methods * ev_methods;
|
|
void * ev_softc;
|
|
|
|
/* Sysctl: */
|
|
struct sysctl_ctx_list ev_sysctl_ctx;
|
|
|
|
LIST_ENTRY(evdev_dev) ev_link;
|
|
CK_SLIST_HEAD(, evdev_client) ev_clients; /* (l) */
|
|
};
|
|
|
|
#define SYSTEM_CONSOLE_LOCK &Giant
|
|
|
|
#define EVDEV_LOCK(evdev) mtx_lock((evdev)->ev_state_lock)
|
|
#define EVDEV_UNLOCK(evdev) mtx_unlock((evdev)->ev_state_lock)
|
|
#define EVDEV_LOCK_ASSERT(evdev) do { \
|
|
if ((evdev)->ev_state_lock != SYSTEM_CONSOLE_LOCK) \
|
|
mtx_assert((evdev)->ev_state_lock, MA_OWNED); \
|
|
} while (0)
|
|
#define EVDEV_ENTER(evdev) do { \
|
|
if ((evdev)->ev_lock_type != EV_LOCK_MTX) \
|
|
EVDEV_LOCK(evdev); \
|
|
else \
|
|
EVDEV_LOCK_ASSERT(evdev); \
|
|
} while (0)
|
|
#define EVDEV_EXIT(evdev) do { \
|
|
if ((evdev)->ev_lock_type != EV_LOCK_MTX) \
|
|
EVDEV_UNLOCK(evdev); \
|
|
} while (0)
|
|
|
|
#define EVDEV_LIST_LOCK(evdev) do { \
|
|
if ((evdev)->ev_lock_type == EV_LOCK_MTX) \
|
|
EVDEV_LOCK(evdev); \
|
|
else \
|
|
sx_xlock(&(evdev)->ev_list_lock); \
|
|
} while (0)
|
|
#define EVDEV_LIST_UNLOCK(evdev) do { \
|
|
if ((evdev)->ev_lock_type == EV_LOCK_MTX) \
|
|
EVDEV_UNLOCK(evdev); \
|
|
else \
|
|
sx_unlock(&(evdev)->ev_list_lock); \
|
|
} while (0)
|
|
#define EVDEV_LIST_LOCK_ASSERT(evdev) do { \
|
|
if ((evdev)->ev_lock_type == EV_LOCK_MTX) \
|
|
EVDEV_LOCK_ASSERT(evdev); \
|
|
else \
|
|
sx_assert(&(evdev)->ev_list_lock, MA_OWNED); \
|
|
} while (0)
|
|
static inline int
|
|
EVDEV_LIST_LOCK_SIG(struct evdev_dev *evdev)
|
|
{
|
|
if (evdev->ev_lock_type == EV_LOCK_MTX) {
|
|
EVDEV_LOCK(evdev);
|
|
return (0);
|
|
}
|
|
return (sx_xlock_sig(&evdev->ev_list_lock));
|
|
}
|
|
|
|
struct evdev_client
|
|
{
|
|
struct evdev_dev * ec_evdev;
|
|
struct mtx ec_buffer_mtx; /* Client queue lock */
|
|
size_t ec_buffer_size;
|
|
size_t ec_buffer_head; /* (q) */
|
|
size_t ec_buffer_tail; /* (q) */
|
|
size_t ec_buffer_ready; /* (q) */
|
|
enum evdev_clock_id ec_clock_id;
|
|
struct selinfo ec_selp; /* (q) */
|
|
struct sigio * ec_sigio;
|
|
bool ec_async; /* (q) */
|
|
bool ec_revoked; /* (l) */
|
|
bool ec_blocked; /* (q) */
|
|
bool ec_selected; /* (q) */
|
|
|
|
CK_SLIST_ENTRY(evdev_client) ec_link; /* (l) */
|
|
|
|
struct input_event ec_buffer[]; /* (q) */
|
|
};
|
|
|
|
#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)
|
|
#define EVDEV_CLIENT_SIZEQ(client) \
|
|
(((client)->ec_buffer_ready + (client)->ec_buffer_size - \
|
|
(client)->ec_buffer_head) % (client)->ec_buffer_size)
|
|
|
|
/* bitstring(3) helper */
|
|
static inline void
|
|
bit_change(bitstr_t *bitstr, int bit, int value)
|
|
{
|
|
if (value)
|
|
bit_set(bitstr, bit);
|
|
else
|
|
bit_clear(bitstr, bit);
|
|
}
|
|
|
|
/* Input device interface: */
|
|
void evdev_send_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_cdev_create(struct evdev_dev *);
|
|
int evdev_cdev_destroy(struct evdev_dev *);
|
|
bool evdev_event_supported(struct evdev_dev *, uint16_t);
|
|
void evdev_set_abs_bit(struct evdev_dev *, uint16_t);
|
|
void evdev_set_absinfo(struct evdev_dev *, uint16_t, struct input_absinfo *);
|
|
void evdev_restore_after_kdb(struct evdev_dev *);
|
|
|
|
/* Client interface: */
|
|
int evdev_register_client(struct evdev_dev *, struct evdev_client *);
|
|
void evdev_dispose_client(struct evdev_dev *, struct evdev_client *);
|
|
int evdev_grab_client(struct evdev_dev *, struct evdev_client *);
|
|
int evdev_release_client(struct evdev_dev *, struct evdev_client *);
|
|
void evdev_client_push(struct evdev_client *, uint16_t, uint16_t, int32_t);
|
|
void evdev_notify_event(struct evdev_client *);
|
|
void evdev_revoke_client(struct evdev_client *);
|
|
|
|
/* Multitouch related functions: */
|
|
void evdev_mt_init(struct evdev_dev *);
|
|
void evdev_mt_free(struct evdev_dev *);
|
|
void evdev_mt_sync_frame(struct evdev_dev *);
|
|
int evdev_mt_get_last_slot(struct evdev_dev *);
|
|
void evdev_mt_set_last_slot(struct evdev_dev *, int);
|
|
int32_t evdev_mt_get_value(struct evdev_dev *, int, int16_t);
|
|
void evdev_mt_set_value(struct evdev_dev *, int, int16_t, int32_t);
|
|
int32_t evdev_mt_reassign_id(struct evdev_dev *, int, int32_t);
|
|
bool evdev_mt_record_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);
|
|
|
|
/* Utility functions: */
|
|
void evdev_client_dumpqueue(struct evdev_client *);
|
|
void evdev_send_nfingers(struct evdev_dev *, int);
|
|
|
|
#endif /* _DEV_EVDEV_EVDEV_PRIVATE_H */
|