#define DEFAULT_AXIS_STEP_DISTANCE 10
+enum evdev_key_type {
+ EVDEV_KEY_TYPE_NONE,
+ EVDEV_KEY_TYPE_KEY,
+ EVDEV_KEY_TYPE_BUTTON,
+};
+
+static void
+set_key_down(struct evdev_device *device, int code, int pressed)
+{
+ long_set_bit_state(device->key_mask, code, pressed);
+}
+
+static int
+is_key_down(struct evdev_device *device, int code)
+{
+ return long_bit_is_set(device->key_mask, code);
+}
+
+static int
+get_key_down_count(struct evdev_device *device, int code)
+{
+ return device->key_count[code];
+}
+
+static int
+update_key_down_count(struct evdev_device *device, int code, int pressed)
+{
+ int key_count;
+ assert(code >= 0 && code < KEY_CNT);
+
+ if (pressed) {
+ key_count = ++device->key_count[code];
+ } else {
+ assert(device->key_count[code] > 0);
+ key_count = --device->key_count[code];
+ }
+
+ if (key_count > 32) {
+ log_bug_libinput(device->base.seat->libinput,
+ "Key count for %s reached abnormal values\n",
+ libevdev_event_code_get_name(EV_KEY, code));
+ }
+
+ return key_count;
+}
+
+void
+evdev_keyboard_notify_key(struct evdev_device *device,
+ uint32_t time,
+ int key,
+ enum libinput_key_state state)
+{
+ int down_count;
+
+ down_count = update_key_down_count(device, key, state);
+
+ if ((state == LIBINPUT_KEY_STATE_PRESSED && down_count == 1) ||
+ (state == LIBINPUT_KEY_STATE_RELEASED && down_count == 0))
+ keyboard_notify_key(&device->base, time, key, state);
+}
+
+void
+evdev_pointer_notify_button(struct evdev_device *device,
+ uint32_t time,
+ int button,
+ enum libinput_button_state state)
+{
+ int down_count;
+
+ down_count = update_key_down_count(device, button, state);
+
+ if ((state == LIBINPUT_BUTTON_STATE_PRESSED && down_count == 1) ||
+ (state == LIBINPUT_BUTTON_STATE_RELEASED && down_count == 0))
+ pointer_notify_button(&device->base, time, button, state);
+}
+
void
evdev_device_led_update(struct evdev_device *device, enum libinput_led leds)
{
}
}
+static inline double
+scale_axis(const struct input_absinfo *absinfo, double val, double to_range)
+{
+ return (val - absinfo->minimum) * to_range /
+ (absinfo->maximum - absinfo->minimum + 1);
+}
+
double
evdev_device_transform_x(struct evdev_device *device,
double x,
uint32_t width)
{
- return (x - device->abs.min_x) * width /
- (device->abs.max_x - device->abs.min_x + 1);
+ return scale_axis(device->abs.absinfo_x, x, width);
}
double
double y,
uint32_t height)
{
- return (y - device->abs.min_y) * height /
- (device->abs.max_y - device->abs.min_y + 1);
+ return scale_axis(device->abs.absinfo_y, y, height);
}
static void
evdev_flush_pending_event(struct evdev_device *device, uint64_t time)
{
+ struct libinput *libinput = device->base.seat->libinput;
struct motion_params motion;
int32_t cx, cy;
double x, y;
break;
if (device->mt.slots[slot].seat_slot != -1) {
- log_bug_kernel("%s: Driver sent multiple touch down for the "
+ log_bug_kernel(libinput,
+ "%s: Driver sent multiple touch down for the "
"same slot", device->devnode);
break;
}
break;
if (device->abs.seat_slot != -1) {
- log_bug_kernel("%s: Driver sent multiple touch down for the "
+ log_bug_kernel(libinput,
+ "%s: Driver sent multiple touch down for the "
"same slot", device->devnode);
break;
}
device->pending_event = EVDEV_NONE;
}
+static enum evdev_key_type
+get_key_type(uint16_t code)
+{
+ if (code == BTN_TOUCH)
+ return EVDEV_KEY_TYPE_NONE;
+
+ if (code >= KEY_ESC && code <= KEY_MICMUTE)
+ return EVDEV_KEY_TYPE_KEY;
+ if (code >= BTN_MISC && code <= BTN_GEAR_UP)
+ return EVDEV_KEY_TYPE_BUTTON;
+ if (code >= KEY_OK && code <= KEY_LIGHTS_TOGGLE)
+ return EVDEV_KEY_TYPE_KEY;
+ if (code >= BTN_DPAD_UP && code <= BTN_TRIGGER_HAPPY40)
+ return EVDEV_KEY_TYPE_BUTTON;
+ return EVDEV_KEY_TYPE_NONE;
+}
+
static void
evdev_process_touch_button(struct evdev_device *device,
uint64_t time, int value)
evdev_process_key(struct evdev_device *device,
struct input_event *e, uint64_t time)
{
+ enum evdev_key_type type;
+
/* ignore kernel key repeat */
if (e->value == 2)
return;
- if (e->code > KEY_MAX)
- return;
-
if (e->code == BTN_TOUCH) {
if (!device->is_mt)
evdev_process_touch_button(device, time, e->value);
evdev_flush_pending_event(device, time);
- switch (e->code) {
- case BTN_LEFT:
- case BTN_RIGHT:
- case BTN_MIDDLE:
- case BTN_SIDE:
- case BTN_EXTRA:
- case BTN_FORWARD:
- case BTN_BACK:
- case BTN_TASK:
- pointer_notify_button(
- &device->base,
- time,
- e->code,
- e->value ? LIBINPUT_BUTTON_STATE_PRESSED :
- LIBINPUT_BUTTON_STATE_RELEASED);
- break;
+ type = get_key_type(e->code);
- default:
- /* Only let KEY_* codes pass through. */
- if (!(e->code <= KEY_MICMUTE ||
- (e->code >= KEY_OK && e->code <= KEY_LIGHTS_TOGGLE)))
+ /* Ignore key release events from the kernel for keys that libinput
+ * never got a pressed event for. */
+ if (e->value == 0) {
+ switch (type) {
+ case EVDEV_KEY_TYPE_NONE:
break;
+ case EVDEV_KEY_TYPE_KEY:
+ case EVDEV_KEY_TYPE_BUTTON:
+ if (!is_key_down(device, e->code))
+ return;
+ }
+ }
- keyboard_notify_key(
- &device->base,
+ set_key_down(device, e->code, e->value);
+
+ switch (type) {
+ case EVDEV_KEY_TYPE_NONE:
+ break;
+ case EVDEV_KEY_TYPE_KEY:
+ evdev_keyboard_notify_key(
+ device,
time,
e->code,
- e->value ? LIBINPUT_KEYBOARD_KEY_STATE_PRESSED :
- LIBINPUT_KEYBOARD_KEY_STATE_RELEASED);
+ e->value ? LIBINPUT_KEY_STATE_PRESSED :
+ LIBINPUT_KEY_STATE_RELEASED);
+ break;
+ case EVDEV_KEY_TYPE_BUTTON:
+ evdev_pointer_notify_button(
+ device,
+ time,
+ e->code,
+ e->value ? LIBINPUT_BUTTON_STATE_PRESSED :
+ LIBINPUT_BUTTON_STATE_RELEASED);
break;
}
}
pointer_notify_axis(
base,
time,
- LIBINPUT_POINTER_AXIS_VERTICAL_SCROLL,
+ LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL,
-1 * e->value * DEFAULT_AXIS_STEP_DISTANCE);
break;
case REL_HWHEEL:
pointer_notify_axis(
base,
time,
- LIBINPUT_POINTER_AXIS_HORIZONTAL_SCROLL,
+ LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL,
e->value * DEFAULT_AXIS_STEP_DISTANCE);
break;
default:
static int
evdev_configure_device(struct evdev_device *device)
{
+ struct libinput *libinput = device->base.seat->libinput;
struct libevdev *evdev = device->evdev;
const struct input_absinfo *absinfo;
+ struct input_absinfo fixed;
int has_abs, has_rel, has_mt;
int has_button, has_keyboard, has_touch;
struct mt_slot *slots;
if (libevdev_has_event_type(evdev, EV_ABS)) {
if ((absinfo = libevdev_get_abs_info(evdev, ABS_X))) {
- device->abs.min_x = absinfo->minimum;
- device->abs.max_x = absinfo->maximum;
+ if (absinfo->resolution == 0) {
+ fixed = *absinfo;
+ fixed.resolution = 1;
+ libevdev_set_abs_info(evdev, ABS_X, &fixed);
+ device->abs.fake_resolution = 1;
+ }
+ device->abs.absinfo_x = absinfo;
has_abs = 1;
}
if ((absinfo = libevdev_get_abs_info(evdev, ABS_Y))) {
- device->abs.min_y = absinfo->minimum;
- device->abs.max_y = absinfo->maximum;
+ if (absinfo->resolution == 0) {
+ fixed = *absinfo;
+ fixed.resolution = 1;
+ libevdev_set_abs_info(evdev, ABS_Y, &fixed);
+ device->abs.fake_resolution = 1;
+ }
+ device->abs.absinfo_y = absinfo;
has_abs = 1;
}
/* We only handle the slotted Protocol B in weston.
if (libevdev_has_event_code(evdev, EV_ABS, ABS_MT_POSITION_X) &&
libevdev_has_event_code(evdev, EV_ABS, ABS_MT_POSITION_Y)) {
absinfo = libevdev_get_abs_info(evdev, ABS_MT_POSITION_X);
- device->abs.min_x = absinfo->minimum;
- device->abs.max_x = absinfo->maximum;
+ if (absinfo->resolution == 0) {
+ fixed = *absinfo;
+ fixed.resolution = 1;
+ libevdev_set_abs_info(evdev,
+ ABS_MT_POSITION_X,
+ &fixed);
+ device->abs.fake_resolution = 1;
+ }
+ device->abs.absinfo_x = absinfo;
absinfo = libevdev_get_abs_info(evdev, ABS_MT_POSITION_Y);
- device->abs.min_y = absinfo->minimum;
- device->abs.max_y = absinfo->maximum;
+ if (absinfo->resolution == 0) {
+ fixed = *absinfo;
+ fixed.resolution = 1;
+ libevdev_set_abs_info(evdev,
+ ABS_MT_POSITION_Y,
+ &fixed);
+ device->abs.fake_resolution = 1;
+ }
+ device->abs.absinfo_y = absinfo;
device->is_mt = 1;
has_touch = 1;
has_mt = 1;
!libevdev_has_event_code(evdev, EV_KEY, BTN_TOOL_PEN) &&
(has_abs || has_mt)) {
device->dispatch = evdev_mt_touchpad_create(device);
- log_info("input device '%s', %s is a touchpad\n",
+ log_info(libinput,
+ "input device '%s', %s is a touchpad\n",
device->devname, device->devnode);
+ return device->dispatch == NULL ? -1 : 0;
}
- for (i = KEY_ESC; i < KEY_MAX; i++) {
- if (i >= BTN_MISC && i < KEY_OK)
- continue;
+
+ for (i = 0; i < KEY_MAX; i++) {
if (libevdev_has_event_code(evdev, EV_KEY, i)) {
- has_keyboard = 1;
- break;
+ switch (get_key_type(i)) {
+ case EVDEV_KEY_TYPE_NONE:
+ break;
+ case EVDEV_KEY_TYPE_KEY:
+ has_keyboard = 1;
+ break;
+ case EVDEV_KEY_TYPE_BUTTON:
+ has_button = 1;
+ break;
+ }
}
}
+
if (libevdev_has_event_code(evdev, EV_KEY, BTN_TOUCH))
has_touch = 1;
- for (i = BTN_MISC; i < BTN_JOYSTICK; i++) {
- if (libevdev_has_event_code(evdev, EV_KEY, i)) {
- has_button = 1;
- break;
- }
- }
}
if (libevdev_has_event_type(evdev, EV_LED))
has_keyboard = 1;
device->seat_caps |= EVDEV_DEVICE_POINTER;
- log_info("input device '%s', %s is a pointer caps =%s%s%s\n",
+ log_info(libinput,
+ "input device '%s', %s is a pointer caps =%s%s%s\n",
device->devname, device->devnode,
has_abs ? " absolute-motion" : "",
has_rel ? " relative-motion": "",
}
if (has_keyboard) {
device->seat_caps |= EVDEV_DEVICE_KEYBOARD;
- log_info("input device '%s', %s is a keyboard\n",
+ log_info(libinput,
+ "input device '%s', %s is a keyboard\n",
device->devname, device->devnode);
}
if (has_touch && !has_button) {
device->seat_caps |= EVDEV_DEVICE_TOUCH;
- log_info("input device '%s', %s is a touch device\n",
+ log_info(libinput,
+ "input device '%s', %s is a touch device\n",
device->devname, device->devnode);
}
* read. mtdev_get() also expects this. */
fd = open_restricted(libinput, devnode, O_RDWR | O_NONBLOCK);
if (fd < 0) {
- log_info("opening input device '%s' failed (%s).\n",
+ log_info(libinput,
+ "opening input device '%s' failed (%s).\n",
devnode, strerror(-fd));
return NULL;
}
return NULL;
libinput_device_init(&device->base, seat);
+ libinput_seat_ref(seat);
rc = libevdev_new_from_fd(fd, &device->evdev);
if (rc != 0)
- return NULL;
+ goto err;
libevdev_set_clock_id(device->evdev, CLOCK_MONOTONIC);
device->pending_event = EVDEV_NONE;
device->devname = libevdev_get_name(device->evdev);
- libinput_seat_ref(seat);
-
if (evdev_configure_device(device) == -1)
goto err;
int
evdev_device_get_keys(struct evdev_device *device, char *keys, size_t size)
{
- int len;
-
memset(keys, 0, size);
- len = ioctl(device->fd, EVIOCGKEY(size), keys);
-
- return (len == -1) ? -errno : len;
+ return 0;
}
const char *
return device->sysname;
}
+const char *
+evdev_device_get_name(struct evdev_device *device)
+{
+ return device->devname;
+}
+
+unsigned int
+evdev_device_get_id_product(struct evdev_device *device)
+{
+ return libevdev_get_id_product(device->evdev);
+}
+
+unsigned int
+evdev_device_get_id_vendor(struct evdev_device *device)
+{
+ return libevdev_get_id_vendor(device->evdev);
+}
+
void
evdev_device_calibrate(struct evdev_device *device, float calibration[6])
{
}
}
+int
+evdev_device_get_size(struct evdev_device *device,
+ double *width,
+ double *height)
+{
+ const struct input_absinfo *x, *y;
+
+ x = libevdev_get_abs_info(device->evdev, ABS_X);
+ y = libevdev_get_abs_info(device->evdev, ABS_Y);
+
+ if (!x || !y || device->abs.fake_resolution ||
+ !x->resolution || !y->resolution)
+ return -1;
+
+ *width = evdev_convert_to_mm(x, x->maximum);
+ *height = evdev_convert_to_mm(y, y->maximum);
+
+ return 0;
+}
+
+static void
+release_pressed_keys(struct evdev_device *device)
+{
+ struct libinput *libinput = device->base.seat->libinput;
+ struct timespec ts;
+ uint64_t time;
+ int code;
+
+ if (clock_gettime(CLOCK_MONOTONIC, &ts) != 0) {
+ log_bug_libinput(libinput, "clock_gettime: %s\n", strerror(errno));
+ return;
+ }
+
+ time = ts.tv_sec * 1000ULL + ts.tv_nsec / 1000000;
+
+ for (code = 0; code < KEY_CNT; code++) {
+ if (get_key_down_count(device, code) > 0) {
+ switch (get_key_type(code)) {
+ case EVDEV_KEY_TYPE_NONE:
+ break;
+ case EVDEV_KEY_TYPE_KEY:
+ keyboard_notify_key(
+ &device->base,
+ time,
+ code,
+ LIBINPUT_KEY_STATE_RELEASED);
+ break;
+ case EVDEV_KEY_TYPE_BUTTON:
+ pointer_notify_button(
+ &device->base,
+ time,
+ code,
+ LIBINPUT_BUTTON_STATE_RELEASED);
+ break;
+ }
+ }
+ }
+}
+
void
evdev_device_remove(struct evdev_device *device)
{
libinput_remove_source(device->base.seat->libinput,
device->source);
+ release_pressed_keys(device);
+
if (device->mtdev)
mtdev_close_delete(device->mtdev);
close_restricted(device->base.seat->libinput, device->fd);
if (dispatch)
dispatch->interface->destroy(dispatch);
- motion_filter_destroy(device->pointer.filter);
+ filter_destroy(device->pointer.filter);
libinput_seat_unref(device->base.seat);
libevdev_free(device->evdev);
free(device->mt.slots);
projects / platform / upstream / libinput.git / blobdiff