2 * Copyright © 2010 Intel Corporation
4 * Permission to use, copy, modify, distribute, and sell this software and
5 * its documentation for any purpose is hereby granted without fee, provided
6 * that the above copyright notice appear in all copies and that both that
7 * copyright notice and this permission notice appear in supporting
8 * documentation, and that the name of the copyright holders not be used in
9 * advertising or publicity pertaining to distribution of the software
10 * without specific, written prior permission. The copyright holders make
11 * no representations about the suitability of this software for any
12 * purpose. It is provided "as is" without express or implied warranty.
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
15 * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
17 * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
18 * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
19 * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
20 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
27 #include <linux/input.h>
33 #include "compositor.h"
36 #define DEFAULT_AXIS_STEP_DISTANCE wl_fixed_from_int(10)
39 evdev_led_update(struct evdev_device *device, enum weston_led leds)
42 enum weston_led weston;
45 { LED_NUM_LOCK, LED_NUML },
46 { LED_CAPS_LOCK, LED_CAPSL },
47 { LED_SCROLL_LOCK, LED_SCROLLL },
49 struct input_event ev[ARRAY_LENGTH(map) + 1];
52 if (!device->caps & EVDEV_KEYBOARD)
55 memset(ev, 0, sizeof(ev));
56 for (i = 0; i < ARRAY_LENGTH(map); i++) {
58 ev[i].code = map[i].evdev;
59 ev[i].value = !!(leds & map[i].weston);
62 ev[i].code = SYN_REPORT;
64 i = write(device->fd, ev, sizeof ev);
65 (void)i; /* no, we really don't care about the return value */
69 transform_absolute(struct evdev_device *device, int32_t *x, int32_t *y)
71 if (!device->abs.apply_calibration) {
76 *x = device->abs.x * device->abs.calibration[0] +
77 device->abs.y * device->abs.calibration[1] +
78 device->abs.calibration[2];
80 *y = device->abs.x * device->abs.calibration[3] +
81 device->abs.y * device->abs.calibration[4] +
82 device->abs.calibration[5];
87 evdev_flush_pending_event(struct evdev_device *device, uint32_t time)
89 struct weston_seat *master = device->seat;
94 slot = device->mt.slot;
96 switch (device->pending_event) {
99 case EVDEV_RELATIVE_MOTION:
100 notify_motion(master, time, device->rel.dx, device->rel.dy);
104 case EVDEV_ABSOLUTE_MT_DOWN:
105 weston_output_transform_coordinate(device->output,
106 device->mt.slots[slot].x,
107 device->mt.slots[slot].y,
109 notify_touch(master, time,
110 slot, x, y, WL_TOUCH_DOWN);
112 case EVDEV_ABSOLUTE_MT_MOTION:
113 weston_output_transform_coordinate(device->output,
114 device->mt.slots[slot].x,
115 device->mt.slots[slot].y,
117 notify_touch(master, time,
118 slot, x, y, WL_TOUCH_MOTION);
120 case EVDEV_ABSOLUTE_MT_UP:
121 notify_touch(master, time, slot, 0, 0,
124 case EVDEV_ABSOLUTE_MOTION:
125 transform_absolute(device, &cx, &cy);
126 weston_output_transform_coordinate(device->output,
129 if (device->caps & EVDEV_TOUCH) {
130 if (master->num_tp == 0)
131 notify_touch(master, time, 0,
132 x, y, WL_TOUCH_DOWN);
134 notify_touch(master, time, 0,
135 x, y, WL_TOUCH_MOTION);
137 notify_motion_absolute(master, time, x, y);
141 assert(0 && "Unknown pending event type");
144 device->pending_event = EVDEV_NONE;
148 evdev_process_key(struct evdev_device *device, struct input_event *e, int time)
150 /* ignore kernel key repeat */
154 evdev_flush_pending_event(device, time);
165 notify_button(device->seat,
167 e->value ? WL_POINTER_BUTTON_STATE_PRESSED :
168 WL_POINTER_BUTTON_STATE_RELEASED);
172 if (e->value == 0 && !device->is_mt)
173 notify_touch(device->seat, time, 0, 0, 0,
177 notify_key(device->seat,
179 e->value ? WL_KEYBOARD_KEY_STATE_PRESSED :
180 WL_KEYBOARD_KEY_STATE_RELEASED,
181 STATE_UPDATE_AUTOMATIC);
187 evdev_process_touch(struct evdev_device *device,
188 struct input_event *e,
191 const int screen_width = device->output->current_mode->width;
192 const int screen_height = device->output->current_mode->height;
196 evdev_flush_pending_event(device, time);
197 device->mt.slot = e->value;
199 case ABS_MT_TRACKING_ID:
200 if (device->pending_event != EVDEV_NONE &&
201 device->pending_event != EVDEV_ABSOLUTE_MT_MOTION)
202 evdev_flush_pending_event(device, time);
204 device->pending_event = EVDEV_ABSOLUTE_MT_DOWN;
206 device->pending_event = EVDEV_ABSOLUTE_MT_UP;
208 case ABS_MT_POSITION_X:
209 device->mt.slots[device->mt.slot].x =
210 (e->value - device->abs.min_x) * screen_width /
211 (device->abs.max_x - device->abs.min_x);
212 if (device->pending_event == EVDEV_NONE)
213 device->pending_event = EVDEV_ABSOLUTE_MT_MOTION;
215 case ABS_MT_POSITION_Y:
216 device->mt.slots[device->mt.slot].y =
217 (e->value - device->abs.min_y) * screen_height /
218 (device->abs.max_y - device->abs.min_y);
219 if (device->pending_event == EVDEV_NONE)
220 device->pending_event = EVDEV_ABSOLUTE_MT_MOTION;
226 evdev_process_absolute_motion(struct evdev_device *device,
227 struct input_event *e)
229 const int screen_width = device->output->current_mode->width;
230 const int screen_height = device->output->current_mode->height;
235 (e->value - device->abs.min_x) * screen_width /
236 (device->abs.max_x - device->abs.min_x);
237 if (device->pending_event == EVDEV_NONE)
238 device->pending_event = EVDEV_ABSOLUTE_MOTION;
242 (e->value - device->abs.min_y) * screen_height /
243 (device->abs.max_y - device->abs.min_y);
244 if (device->pending_event == EVDEV_NONE)
245 device->pending_event = EVDEV_ABSOLUTE_MOTION;
251 evdev_process_relative(struct evdev_device *device,
252 struct input_event *e, uint32_t time)
256 if (device->pending_event != EVDEV_RELATIVE_MOTION)
257 evdev_flush_pending_event(device, time);
258 device->rel.dx += wl_fixed_from_int(e->value);
259 device->pending_event = EVDEV_RELATIVE_MOTION;
262 if (device->pending_event != EVDEV_RELATIVE_MOTION)
263 evdev_flush_pending_event(device, time);
264 device->rel.dy += wl_fixed_from_int(e->value);
265 device->pending_event = EVDEV_RELATIVE_MOTION;
268 evdev_flush_pending_event(device, time);
274 notify_axis(device->seat,
276 WL_POINTER_AXIS_VERTICAL_SCROLL,
277 -1 * e->value * DEFAULT_AXIS_STEP_DISTANCE);
284 evdev_flush_pending_event(device, time);
290 notify_axis(device->seat,
292 WL_POINTER_AXIS_HORIZONTAL_SCROLL,
293 e->value * DEFAULT_AXIS_STEP_DISTANCE);
303 evdev_process_absolute(struct evdev_device *device,
304 struct input_event *e,
308 evdev_process_touch(device, e, time);
310 evdev_process_absolute_motion(device, e);
315 fallback_process(struct evdev_dispatch *dispatch,
316 struct evdev_device *device,
317 struct input_event *event,
320 switch (event->type) {
322 evdev_process_relative(device, event, time);
325 evdev_process_absolute(device, event, time);
328 evdev_process_key(device, event, time);
331 evdev_flush_pending_event(device, time);
337 fallback_destroy(struct evdev_dispatch *dispatch)
342 struct evdev_dispatch_interface fallback_interface = {
347 static struct evdev_dispatch *
348 fallback_dispatch_create(void)
350 struct evdev_dispatch *dispatch = malloc(sizeof *dispatch);
351 if (dispatch == NULL)
354 dispatch->interface = &fallback_interface;
360 evdev_process_events(struct evdev_device *device,
361 struct input_event *ev, int count)
363 struct evdev_dispatch *dispatch = device->dispatch;
364 struct input_event *e, *end;
369 for (e = ev; e < end; e++) {
370 time = e->time.tv_sec * 1000 + e->time.tv_usec / 1000;
372 dispatch->interface->process(dispatch, device, e, time);
377 evdev_device_data(int fd, uint32_t mask, void *data)
379 struct weston_compositor *ec;
380 struct evdev_device *device = data;
381 struct input_event ev[32];
384 ec = device->seat->compositor;
388 /* If the compositor is repainting, this function is called only once
389 * per frame and we have to process all the events available on the
390 * fd, otherwise there will be input lag. */
393 len = mtdev_get(device->mtdev, fd, ev,
395 sizeof (struct input_event);
397 len = read(fd, &ev, sizeof ev);
399 if (len < 0 || len % sizeof ev[0] != 0) {
400 /* FIXME: call evdev_device_destroy when errno is ENODEV. */
404 evdev_process_events(device, ev, len / sizeof ev[0]);
412 evdev_handle_device(struct evdev_device *device)
414 struct input_absinfo absinfo;
415 unsigned long ev_bits[NBITS(EV_MAX)];
416 unsigned long abs_bits[NBITS(ABS_MAX)];
417 unsigned long rel_bits[NBITS(REL_MAX)];
418 unsigned long key_bits[NBITS(KEY_MAX)];
419 int has_key, has_abs;
426 ioctl(device->fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits);
427 if (TEST_BIT(ev_bits, EV_ABS)) {
430 ioctl(device->fd, EVIOCGBIT(EV_ABS, sizeof(abs_bits)),
433 if (TEST_BIT(abs_bits, ABS_WHEEL) ||
434 TEST_BIT(abs_bits, ABS_GAS) ||
435 TEST_BIT(abs_bits, ABS_BRAKE) ||
436 TEST_BIT(abs_bits, ABS_HAT0X)) {
437 weston_log("device %s is a joystick, ignoring\n",
442 if (TEST_BIT(abs_bits, ABS_X)) {
443 ioctl(device->fd, EVIOCGABS(ABS_X), &absinfo);
444 device->abs.min_x = absinfo.minimum;
445 device->abs.max_x = absinfo.maximum;
446 device->caps |= EVDEV_MOTION_ABS;
448 if (TEST_BIT(abs_bits, ABS_Y)) {
449 ioctl(device->fd, EVIOCGABS(ABS_Y), &absinfo);
450 device->abs.min_y = absinfo.minimum;
451 device->abs.max_y = absinfo.maximum;
452 device->caps |= EVDEV_MOTION_ABS;
454 /* We only handle the slotted Protocol B in weston.
455 Devices with ABS_MT_POSITION_* but not ABS_MT_SLOT
456 require mtdev for conversion. */
457 if (TEST_BIT(abs_bits, ABS_MT_POSITION_X) &&
458 TEST_BIT(abs_bits, ABS_MT_POSITION_Y)) {
459 ioctl(device->fd, EVIOCGABS(ABS_MT_POSITION_X),
461 device->abs.min_x = absinfo.minimum;
462 device->abs.max_x = absinfo.maximum;
463 ioctl(device->fd, EVIOCGABS(ABS_MT_POSITION_Y),
465 device->abs.min_y = absinfo.minimum;
466 device->abs.max_y = absinfo.maximum;
468 device->caps |= EVDEV_TOUCH;
470 if (!TEST_BIT(abs_bits, ABS_MT_SLOT)) {
471 device->mtdev = mtdev_new_open(device->fd);
472 if (!device->mtdev) {
473 weston_log("mtdev required but failed to open for %s\n",
477 device->mt.slot = device->mtdev->caps.slot.value;
479 ioctl(device->fd, EVIOCGABS(ABS_MT_SLOT),
481 device->mt.slot = absinfo.value;
485 if (TEST_BIT(ev_bits, EV_REL)) {
486 ioctl(device->fd, EVIOCGBIT(EV_REL, sizeof(rel_bits)),
488 if (TEST_BIT(rel_bits, REL_X) || TEST_BIT(rel_bits, REL_Y))
489 device->caps |= EVDEV_MOTION_REL;
491 if (TEST_BIT(ev_bits, EV_KEY)) {
493 ioctl(device->fd, EVIOCGBIT(EV_KEY, sizeof(key_bits)),
495 if (TEST_BIT(key_bits, BTN_TOOL_FINGER) &&
496 !TEST_BIT(key_bits, BTN_TOOL_PEN) &&
498 device->dispatch = evdev_touchpad_create(device);
499 weston_log("input device %s, %s is a touchpad\n",
500 device->devname, device->devnode);
502 for (i = KEY_ESC; i < KEY_MAX; i++) {
503 if (i >= BTN_MISC && i < KEY_OK)
505 if (TEST_BIT(key_bits, i)) {
506 device->caps |= EVDEV_KEYBOARD;
510 for (i = BTN_MISC; i < KEY_OK; i++) {
511 if (TEST_BIT(key_bits, i)) {
512 device->caps |= EVDEV_BUTTON;
516 if (TEST_BIT(key_bits, BTN_TOUCH)) {
517 device->caps |= EVDEV_TOUCH;
521 if (TEST_BIT(ev_bits, EV_LED)) {
522 device->caps |= EVDEV_KEYBOARD;
525 /* This rule tries to catch accelerometer devices and opt out. We may
526 * want to adjust the protocol later adding a proper event for dealing
527 * with accelerometers and implement here accordingly */
528 if (has_abs && !has_key && !device->is_mt) {
529 weston_log("input device %s, %s "
530 "ignored: unsupported device type\n",
531 device->devname, device->devnode);
539 evdev_configure_device(struct evdev_device *device)
542 (EVDEV_MOTION_ABS | EVDEV_MOTION_REL | EVDEV_BUTTON))) {
543 weston_seat_init_pointer(device->seat);
544 weston_log("input device %s, %s is a pointer caps =%s%s%s\n",
545 device->devname, device->devnode,
546 device->caps & EVDEV_MOTION_ABS ? " absolute-motion" : "",
547 device->caps & EVDEV_MOTION_REL ? " relative-motion": "",
548 device->caps & EVDEV_BUTTON ? " button" : "");
550 if ((device->caps & EVDEV_KEYBOARD)) {
551 if (weston_seat_init_keyboard(device->seat, NULL) < 0)
553 weston_log("input device %s, %s is a keyboard\n",
554 device->devname, device->devnode);
556 if ((device->caps & EVDEV_TOUCH)) {
557 weston_seat_init_touch(device->seat);
558 weston_log("input device %s, %s is a touch device\n",
559 device->devname, device->devnode);
565 struct evdev_device *
566 evdev_device_create(struct weston_seat *seat, const char *path, int device_fd)
568 struct evdev_device *device;
569 struct weston_compositor *ec;
570 char devname[256] = "unknown";
572 device = zalloc(sizeof *device);
576 ec = seat->compositor;
578 container_of(ec->output_list.next, struct weston_output, link);
582 device->mtdev = NULL;
583 device->devnode = strdup(path);
584 device->mt.slot = -1;
587 device->dispatch = NULL;
588 device->fd = device_fd;
589 device->pending_event = EVDEV_NONE;
590 wl_list_init(&device->link);
592 ioctl(device->fd, EVIOCGNAME(sizeof(devname)), devname);
593 devname[sizeof(devname) - 1] = '\0';
594 device->devname = strdup(devname);
596 if (!evdev_handle_device(device)) {
597 evdev_device_destroy(device);
598 return EVDEV_UNHANDLED_DEVICE;
601 if (evdev_configure_device(device) == -1)
604 /* If the dispatch was not set up use the fallback. */
605 if (device->dispatch == NULL)
606 device->dispatch = fallback_dispatch_create();
607 if (device->dispatch == NULL)
610 device->source = wl_event_loop_add_fd(ec->input_loop, device->fd,
612 evdev_device_data, device);
613 if (device->source == NULL)
619 evdev_device_destroy(device);
624 evdev_device_destroy(struct evdev_device *device)
626 struct evdev_dispatch *dispatch;
628 dispatch = device->dispatch;
630 dispatch->interface->destroy(dispatch);
633 wl_event_source_remove(device->source);
634 wl_list_remove(&device->link);
636 mtdev_close_delete(device->mtdev);
638 free(device->devname);
639 free(device->devnode);
644 evdev_notify_keyboard_focus(struct weston_seat *seat,
645 struct wl_list *evdev_devices)
647 struct evdev_device *device;
648 struct wl_array keys;
650 char evdev_keys[(KEY_CNT + 7) / 8];
651 char all_keys[(KEY_CNT + 7) / 8];
658 memset(all_keys, 0, sizeof all_keys);
659 wl_list_for_each(device, evdev_devices, link) {
660 memset(evdev_keys, 0, sizeof evdev_keys);
661 ret = ioctl(device->fd,
662 EVIOCGKEY(sizeof evdev_keys), evdev_keys);
664 weston_log("failed to get keys for device %s\n",
668 for (i = 0; i < ARRAY_LENGTH(evdev_keys); i++)
669 all_keys[i] |= evdev_keys[i];
672 wl_array_init(&keys);
673 for (i = 0; i < KEY_CNT; i++) {
674 set = all_keys[i >> 3] & (1 << (i & 7));
676 k = wl_array_add(&keys, sizeof *k);
681 notify_keyboard_focus_in(seat, &keys, STATE_UPDATE_AUTOMATIC);
683 wl_array_release(&keys);