Add keymap argument to weston_seat_init_keyboard
[profile/ivi/weston.git] / src / evdev.c
1 /*
2  * Copyright © 2010 Intel Corporation
3  *
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.
13  *
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.
21  */
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <linux/input.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29 #include <mtdev.h>
30
31 #include "compositor.h"
32 #include "evdev.h"
33 #include "evdev-private.h"
34 #include "launcher-util.h"
35
36 static void
37 evdev_led_update(struct weston_seat *seat_base, enum weston_led leds)
38 {
39         static const struct {
40                 enum weston_led weston;
41                 int evdev;
42         } map[] = {
43                 { LED_NUM_LOCK, LED_NUML },
44                 { LED_CAPS_LOCK, LED_CAPSL },
45                 { LED_SCROLL_LOCK, LED_SCROLLL },
46         };
47         struct evdev_seat *seat = (struct evdev_seat *) seat_base;
48         struct evdev_input_device *device;
49         struct input_event ev[ARRAY_LENGTH(map)];
50         unsigned int i;
51
52         memset(ev, 0, sizeof(ev));
53         for (i = 0; i < ARRAY_LENGTH(map); i++) {
54                 ev[i].type = EV_LED;
55                 ev[i].code = map[i].evdev;
56                 ev[i].value = !!(leds & map[i].weston);
57         }
58
59         wl_list_for_each(device, &seat->devices_list, link) {
60                 if (device->caps & EVDEV_KEYBOARD)
61                         write(device->fd, ev, sizeof *ev);
62         }
63 }
64
65 static inline void
66 evdev_process_key(struct evdev_input_device *device,
67                         struct input_event *e, int time)
68 {
69         if (e->value == 2)
70                 return;
71
72         switch (e->code) {
73         case BTN_LEFT:
74         case BTN_RIGHT:
75         case BTN_MIDDLE:
76         case BTN_SIDE:
77         case BTN_EXTRA:
78         case BTN_FORWARD:
79         case BTN_BACK:
80         case BTN_TASK:
81                 notify_button(&device->master->base.seat,
82                               time, e->code,
83                               e->value ? WL_POINTER_BUTTON_STATE_PRESSED :
84                                          WL_POINTER_BUTTON_STATE_RELEASED);
85                 break;
86
87         default:
88                 notify_key(&device->master->base.seat,
89                            time, e->code,
90                            e->value ? WL_KEYBOARD_KEY_STATE_PRESSED :
91                                       WL_KEYBOARD_KEY_STATE_RELEASED);
92                 break;
93         }
94 }
95
96 static void
97 evdev_process_touch(struct evdev_input_device *device,
98                     struct input_event *e)
99 {
100         const int screen_width = device->output->current->width;
101         const int screen_height = device->output->current->height;
102
103         switch (e->code) {
104         case ABS_MT_SLOT:
105                 device->mt.slot = e->value;
106                 break;
107         case ABS_MT_TRACKING_ID:
108                 if (e->value >= 0)
109                         device->pending_events |= EVDEV_ABSOLUTE_MT_DOWN;
110                 else
111                         device->pending_events |= EVDEV_ABSOLUTE_MT_UP;
112                 break;
113         case ABS_MT_POSITION_X:
114                 device->mt.x[device->mt.slot] =
115                         (e->value - device->abs.min_x) * screen_width /
116                         (device->abs.max_x - device->abs.min_x) +
117                         device->output->x;
118                 device->pending_events |= EVDEV_ABSOLUTE_MT_MOTION;
119                 break;
120         case ABS_MT_POSITION_Y:
121                 device->mt.y[device->mt.slot] =
122                         (e->value - device->abs.min_y) * screen_height /
123                         (device->abs.max_y - device->abs.min_y) +
124                         device->output->y;
125                 device->pending_events |= EVDEV_ABSOLUTE_MT_MOTION;
126                 break;
127         }
128 }
129
130 static inline void
131 evdev_process_absolute_motion(struct evdev_input_device *device,
132                               struct input_event *e)
133 {
134         const int screen_width = device->output->current->width;
135         const int screen_height = device->output->current->height;
136
137         switch (e->code) {
138         case ABS_X:
139                 device->abs.x =
140                         (e->value - device->abs.min_x) * screen_width /
141                         (device->abs.max_x - device->abs.min_x) +
142                         device->output->x;
143                 device->pending_events |= EVDEV_ABSOLUTE_MOTION;
144                 break;
145         case ABS_Y:
146                 device->abs.y =
147                         (e->value - device->abs.min_y) * screen_height /
148                         (device->abs.max_y - device->abs.min_y) +
149                         device->output->y;
150                 device->pending_events |= EVDEV_ABSOLUTE_MOTION;
151                 break;
152         }
153 }
154
155 static inline void
156 evdev_process_relative(struct evdev_input_device *device,
157                        struct input_event *e, uint32_t time)
158 {
159         switch (e->code) {
160         case REL_X:
161                 device->rel.dx += wl_fixed_from_int(e->value);
162                 device->pending_events |= EVDEV_RELATIVE_MOTION;
163                 break;
164         case REL_Y:
165                 device->rel.dy += wl_fixed_from_int(e->value);
166                 device->pending_events |= EVDEV_RELATIVE_MOTION;
167                 break;
168         case REL_WHEEL:
169                 notify_axis(&device->master->base.seat,
170                               time,
171                               WL_POINTER_AXIS_VERTICAL_SCROLL,
172                               wl_fixed_from_int(e->value));
173                 break;
174         case REL_HWHEEL:
175                 notify_axis(&device->master->base.seat,
176                               time,
177                               WL_POINTER_AXIS_HORIZONTAL_SCROLL,
178                               wl_fixed_from_int(e->value));
179                 break;
180         }
181 }
182
183 static inline void
184 evdev_process_absolute(struct evdev_input_device *device,
185                        struct input_event *e)
186 {
187         if (device->is_mt) {
188                 evdev_process_touch(device, e);
189         } else {
190                 evdev_process_absolute_motion(device, e);
191         }
192 }
193
194 static int
195 is_motion_event(struct input_event *e)
196 {
197         switch (e->type) {
198         case EV_REL:
199                 switch (e->code) {
200                 case REL_X:
201                 case REL_Y:
202                         return 1;
203                 }
204         case EV_ABS:
205                 switch (e->code) {
206                 case ABS_X:
207                 case ABS_Y:
208                 case ABS_MT_POSITION_X:
209                 case ABS_MT_POSITION_Y:
210                         return 1;
211                 }
212         }
213
214         return 0;
215 }
216
217 static void
218 evdev_flush_motion(struct evdev_input_device *device, uint32_t time)
219 {
220         struct weston_seat *master = &device->master->base;
221
222         if (!device->pending_events)
223                 return;
224
225         if (device->pending_events & EVDEV_RELATIVE_MOTION) {
226                 notify_motion(&master->seat, time,
227                               master->seat.pointer->x + device->rel.dx,
228                               master->seat.pointer->y + device->rel.dy);
229                 device->pending_events &= ~EVDEV_RELATIVE_MOTION;
230                 device->rel.dx = 0;
231                 device->rel.dy = 0;
232         }
233         if (device->pending_events & EVDEV_ABSOLUTE_MT_DOWN) {
234                 notify_touch(&master->seat, time,
235                              device->mt.slot,
236                              wl_fixed_from_int(device->mt.x[device->mt.slot]),
237                              wl_fixed_from_int(device->mt.y[device->mt.slot]),
238                              WL_TOUCH_DOWN);
239                 device->pending_events &= ~EVDEV_ABSOLUTE_MT_DOWN;
240                 device->pending_events &= ~EVDEV_ABSOLUTE_MT_MOTION;
241         }
242         if (device->pending_events & EVDEV_ABSOLUTE_MT_MOTION) {
243                 notify_touch(&master->seat, time,
244                              device->mt.slot,
245                              wl_fixed_from_int(device->mt.x[device->mt.slot]),
246                              wl_fixed_from_int(device->mt.y[device->mt.slot]),
247                              WL_TOUCH_MOTION);
248                 device->pending_events &= ~EVDEV_ABSOLUTE_MT_DOWN;
249                 device->pending_events &= ~EVDEV_ABSOLUTE_MT_MOTION;
250         }
251         if (device->pending_events & EVDEV_ABSOLUTE_MT_UP) {
252                 notify_touch(&master->seat, time, device->mt.slot, 0, 0,
253                              WL_TOUCH_UP);
254                 device->pending_events &= ~EVDEV_ABSOLUTE_MT_UP;
255         }
256         if (device->pending_events & EVDEV_ABSOLUTE_MOTION) {
257                 notify_motion(&master->seat, time,
258                               wl_fixed_from_int(device->abs.x),
259                               wl_fixed_from_int(device->abs.y));
260                 device->pending_events &= ~EVDEV_ABSOLUTE_MOTION;
261         }
262 }
263
264 static void
265 fallback_process(struct evdev_dispatch *dispatch,
266                  struct evdev_input_device *device,
267                  struct input_event *event,
268                  uint32_t time)
269 {
270         switch (event->type) {
271         case EV_REL:
272                 evdev_process_relative(device, event, time);
273                 break;
274         case EV_ABS:
275                 evdev_process_absolute(device, event);
276                 break;
277         case EV_KEY:
278                 evdev_process_key(device, event, time);
279                 break;
280         }
281 }
282
283 static void
284 fallback_destroy(struct evdev_dispatch *dispatch)
285 {
286         free(dispatch);
287 }
288
289 struct evdev_dispatch_interface fallback_interface = {
290         fallback_process,
291         fallback_destroy
292 };
293
294 static struct evdev_dispatch *
295 fallback_dispatch_create(void)
296 {
297         struct evdev_dispatch *dispatch = malloc(sizeof *dispatch);
298         if (dispatch == NULL)
299                 return NULL;
300
301         dispatch->interface = &fallback_interface;
302
303         return dispatch;
304 }
305
306 static void
307 evdev_process_events(struct evdev_input_device *device,
308                      struct input_event *ev, int count)
309 {
310         struct evdev_dispatch *dispatch = device->dispatch;
311         struct input_event *e, *end;
312         uint32_t time = 0;
313
314         device->pending_events = 0;
315
316         e = ev;
317         end = e + count;
318         for (e = ev; e < end; e++) {
319                 time = e->time.tv_sec * 1000 + e->time.tv_usec / 1000;
320
321                 /* we try to minimize the amount of notifications to be
322                  * forwarded to the compositor, so we accumulate motion
323                  * events and send as a bunch */
324                 if (!is_motion_event(e))
325                         evdev_flush_motion(device, time);
326
327                 dispatch->interface->process(dispatch, device, e, time);
328         }
329
330         evdev_flush_motion(device, time);
331 }
332
333 static int
334 evdev_input_device_data(int fd, uint32_t mask, void *data)
335 {
336         struct weston_compositor *ec;
337         struct evdev_input_device *device = data;
338         struct input_event ev[32];
339         int len;
340
341         ec = device->master->base.compositor;
342         if (!ec->focus)
343                 return 1;
344
345         /* If the compositor is repainting, this function is called only once
346          * per frame and we have to process all the events available on the
347          * fd, otherwise there will be input lag. */
348         do {
349                 if (device->mtdev)
350                         len = mtdev_get(device->mtdev, fd, ev,
351                                         ARRAY_LENGTH(ev)) *
352                                 sizeof (struct input_event);
353                 else
354                         len = read(fd, &ev, sizeof ev);
355
356                 if (len < 0 || len % sizeof ev[0] != 0) {
357                         /* FIXME: call device_removed when errno is ENODEV. */
358                         return 1;
359                 }
360
361                 evdev_process_events(device, ev, len / sizeof ev[0]);
362
363         } while (len > 0);
364
365         return 1;
366 }
367
368 static int
369 evdev_configure_device(struct evdev_input_device *device)
370 {
371         struct input_absinfo absinfo;
372         unsigned long ev_bits[NBITS(EV_MAX)];
373         unsigned long abs_bits[NBITS(ABS_MAX)];
374         unsigned long rel_bits[NBITS(REL_MAX)];
375         unsigned long key_bits[NBITS(KEY_MAX)];
376         int has_key, has_abs;
377         unsigned int i;
378
379         has_key = 0;
380         has_abs = 0;
381         device->caps = 0;
382
383         ioctl(device->fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits);
384         if (TEST_BIT(ev_bits, EV_ABS)) {
385                 has_abs = 1;
386
387                 ioctl(device->fd, EVIOCGBIT(EV_ABS, sizeof(abs_bits)),
388                       abs_bits);
389                 if (TEST_BIT(abs_bits, ABS_X)) {
390                         ioctl(device->fd, EVIOCGABS(ABS_X), &absinfo);
391                         device->abs.min_x = absinfo.minimum;
392                         device->abs.max_x = absinfo.maximum;
393                         device->caps |= EVDEV_MOTION_ABS;
394                 }
395                 if (TEST_BIT(abs_bits, ABS_Y)) {
396                         ioctl(device->fd, EVIOCGABS(ABS_Y), &absinfo);
397                         device->abs.min_y = absinfo.minimum;
398                         device->abs.max_y = absinfo.maximum;
399                         device->caps |= EVDEV_MOTION_ABS;
400                 }
401                 if (TEST_BIT(abs_bits, ABS_MT_SLOT)) {
402                         device->is_mt = 1;
403                         device->mt.slot = 0;
404                         device->caps |= EVDEV_TOUCH;
405                 }
406         }
407         if (TEST_BIT(ev_bits, EV_REL)) {
408                 ioctl(device->fd, EVIOCGBIT(EV_REL, sizeof(rel_bits)),
409                       rel_bits);
410                 if (TEST_BIT(rel_bits, REL_X) || TEST_BIT(rel_bits, REL_Y))
411                         device->caps |= EVDEV_MOTION_REL;
412         }
413         if (TEST_BIT(ev_bits, EV_KEY)) {
414                 has_key = 1;
415                 ioctl(device->fd, EVIOCGBIT(EV_KEY, sizeof(key_bits)),
416                       key_bits);
417                 if (TEST_BIT(key_bits, BTN_TOOL_FINGER) &&
418                     !TEST_BIT(key_bits, BTN_TOOL_PEN) &&
419                     has_abs)
420                         device->dispatch = evdev_touchpad_create(device);
421                 for (i = KEY_ESC; i < KEY_MAX; i++) {
422                         if (i >= BTN_MISC && i < KEY_OK)
423                                 continue;
424                         if (TEST_BIT(key_bits, i)) {
425                                 device->caps |= EVDEV_KEYBOARD;
426                                 break;
427                         }
428                 }
429                 for (i = BTN_MISC; i < KEY_OK; i++) {
430                         if (TEST_BIT(key_bits, i)) {
431                                 device->caps |= EVDEV_BUTTON;
432                                 break;
433                         }
434                 }
435         }
436
437         /* This rule tries to catch accelerometer devices and opt out. We may
438          * want to adjust the protocol later adding a proper event for dealing
439          * with accelerometers and implement here accordingly */
440         if (has_abs && !has_key)
441                 return -1;
442
443         if ((device->caps &
444              (EVDEV_MOTION_ABS | EVDEV_MOTION_REL | EVDEV_BUTTON)))
445                 weston_seat_init_pointer(&device->master->base);
446         if ((device->caps & EVDEV_KEYBOARD))
447                 weston_seat_init_keyboard(&device->master->base, NULL);
448         if ((device->caps & EVDEV_TOUCH))
449                 weston_seat_init_touch(&device->master->base);
450
451         return 0;
452 }
453
454 static struct evdev_input_device *
455 evdev_input_device_create(struct evdev_seat *master,
456                           struct wl_display *display, const char *path)
457 {
458         struct evdev_input_device *device;
459         struct weston_compositor *ec;
460
461         device = malloc(sizeof *device);
462         if (device == NULL)
463                 return NULL;
464
465         ec = master->base.compositor;
466         device->output =
467                 container_of(ec->output_list.next, struct weston_output, link);
468
469         device->master = master;
470         device->is_mt = 0;
471         device->mtdev = NULL;
472         device->devnode = strdup(path);
473         device->mt.slot = -1;
474         device->rel.dx = 0;
475         device->rel.dy = 0;
476         device->dispatch = NULL;
477
478         /* Use non-blocking mode so that we can loop on read on
479          * evdev_input_device_data() until all events on the fd are
480          * read.  mtdev_get() also expects this. */
481         device->fd = weston_launcher_open(ec, path, O_RDONLY | O_NONBLOCK);
482         if (device->fd < 0)
483                 goto err0;
484
485         if (evdev_configure_device(device) == -1)
486                 goto err1;
487
488         /* If the dispatch was not set up use the fallback. */
489         if (device->dispatch == NULL)
490                 device->dispatch = fallback_dispatch_create();
491         if (device->dispatch == NULL)
492                 goto err1;
493
494
495         if (device->is_mt) {
496                 device->mtdev = mtdev_new_open(device->fd);
497                 if (!device->mtdev)
498                         fprintf(stderr, "mtdev failed to open for %s\n", path);
499         }
500
501         device->source = wl_event_loop_add_fd(ec->input_loop, device->fd,
502                                               WL_EVENT_READABLE,
503                                               evdev_input_device_data, device);
504         if (device->source == NULL)
505                 goto err2;
506
507         wl_list_insert(master->devices_list.prev, &device->link);
508
509         return device;
510
511 err2:
512         device->dispatch->interface->destroy(device->dispatch);
513 err1:
514         close(device->fd);
515 err0:
516         free(device->devnode);
517         free(device);
518         return NULL;
519 }
520
521 static const char default_seat[] = "seat0";
522
523 static void
524 device_added(struct udev_device *udev_device, struct evdev_seat *master)
525 {
526         struct weston_compositor *c;
527         const char *devnode;
528         const char *device_seat;
529
530         device_seat = udev_device_get_property_value(udev_device, "ID_SEAT");
531         if (!device_seat)
532                 device_seat = default_seat;
533
534         if (strcmp(device_seat, master->seat_id))
535                 return;
536
537         c = master->base.compositor;
538         devnode = udev_device_get_devnode(udev_device);
539         evdev_input_device_create(master, c->wl_display, devnode);
540 }
541
542 static void
543 device_removed(struct evdev_input_device *device)
544 {
545         struct evdev_dispatch *dispatch;
546
547         dispatch = device->dispatch;
548         if (dispatch)
549                 dispatch->interface->destroy(dispatch);
550
551         wl_event_source_remove(device->source);
552         wl_list_remove(&device->link);
553         if (device->mtdev)
554                 mtdev_close_delete(device->mtdev);
555         close(device->fd);
556         free(device->devnode);
557         free(device);
558 }
559
560 static void
561 evdev_notify_keyboard_focus(struct evdev_seat *seat)
562 {
563         struct evdev_input_device *device;
564         struct wl_array keys;
565         unsigned int i, set;
566         char evdev_keys[(KEY_CNT + 7) / 8], all_keys[(KEY_CNT + 7) / 8];
567         uint32_t *k;
568         int ret;
569
570         memset(all_keys, 0, sizeof all_keys);
571         wl_list_for_each(device, &seat->devices_list, link) {
572                 memset(evdev_keys, 0, sizeof evdev_keys);
573                 ret = ioctl(device->fd,
574                             EVIOCGKEY(sizeof evdev_keys), evdev_keys);
575                 if (ret < 0) {
576                         fprintf(stderr, "failed to get keys for device %s\n",
577                                 device->devnode);
578                         continue;
579                 }
580                 for (i = 0; i < ARRAY_LENGTH(evdev_keys); i++)
581                         all_keys[i] |= evdev_keys[i];
582         }
583
584         wl_array_init(&keys);
585         for (i = 0; i < KEY_CNT; i++) {
586                 set = all_keys[i >> 3] & (1 << (i & 7));
587                 if (set) {
588                         k = wl_array_add(&keys, sizeof *k);
589                         *k = i;
590                 }
591         }
592
593         notify_keyboard_focus(&seat->base.seat, &keys);
594
595         wl_array_release(&keys);
596 }
597
598 void
599 evdev_add_devices(struct udev *udev, struct weston_seat *seat_base)
600 {
601         struct evdev_seat *seat = (struct evdev_seat *) seat_base;
602         struct udev_enumerate *e;
603         struct udev_list_entry *entry;
604         struct udev_device *device;
605         const char *path, *sysname;
606
607         e = udev_enumerate_new(udev);
608         udev_enumerate_add_match_subsystem(e, "input");
609         udev_enumerate_scan_devices(e);
610         udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
611                 path = udev_list_entry_get_name(entry);
612                 device = udev_device_new_from_syspath(udev, path);
613
614                 sysname = udev_device_get_sysname(device);
615                 if (strncmp("event", sysname, 5) != 0) {
616                         udev_device_unref(device);
617                         continue;
618                 }
619
620                 device_added(device, seat);
621
622                 udev_device_unref(device);
623         }
624         udev_enumerate_unref(e);
625
626         evdev_notify_keyboard_focus(seat);
627
628         if (wl_list_empty(&seat->devices_list)) {
629                 fprintf(stderr,
630                         "warning: no input devices on entering Weston. "
631                         "Possible causes:\n"
632                         "\t- no permissions to read /dev/input/event*\n"
633                         "\t- seats misconfigured "
634                         "(Weston backend option 'seat', "
635                         "udev device property ID_SEAT)\n");
636         }
637 }
638
639 static int
640 evdev_udev_handler(int fd, uint32_t mask, void *data)
641 {
642         struct evdev_seat *master = data;
643         struct udev_device *udev_device;
644         struct evdev_input_device *device, *next;
645         const char *action;
646         const char *devnode;
647
648         udev_device = udev_monitor_receive_device(master->udev_monitor);
649         if (!udev_device)
650                 return 1;
651
652         action = udev_device_get_action(udev_device);
653         if (action) {
654                 if (strncmp("event", udev_device_get_sysname(udev_device), 5) != 0)
655                         return 0;
656
657                 if (!strcmp(action, "add")) {
658                         device_added(udev_device, master);
659                 }
660                 else if (!strcmp(action, "remove")) {
661                         devnode = udev_device_get_devnode(udev_device);
662                         wl_list_for_each_safe(device, next,
663                                               &master->devices_list, link)
664                                 if (!strcmp(device->devnode, devnode)) {
665                                         device_removed(device);
666                                         break;
667                                 }
668                 }
669         }
670         udev_device_unref(udev_device);
671
672         return 0;
673 }
674
675 int
676 evdev_enable_udev_monitor(struct udev *udev, struct weston_seat *seat_base)
677 {
678         struct evdev_seat *master = (struct evdev_seat *) seat_base;
679         struct wl_event_loop *loop;
680         struct weston_compositor *c = master->base.compositor;
681         int fd;
682
683         master->udev_monitor = udev_monitor_new_from_netlink(udev, "udev");
684         if (!master->udev_monitor) {
685                 fprintf(stderr, "udev: failed to create the udev monitor\n");
686                 return 0;
687         }
688
689         udev_monitor_filter_add_match_subsystem_devtype(master->udev_monitor,
690                         "input", NULL);
691
692         if (udev_monitor_enable_receiving(master->udev_monitor)) {
693                 fprintf(stderr, "udev: failed to bind the udev monitor\n");
694                 udev_monitor_unref(master->udev_monitor);
695                 return 0;
696         }
697
698         loop = wl_display_get_event_loop(c->wl_display);
699         fd = udev_monitor_get_fd(master->udev_monitor);
700         master->udev_monitor_source =
701                 wl_event_loop_add_fd(loop, fd, WL_EVENT_READABLE,
702                                      evdev_udev_handler, master);
703         if (!master->udev_monitor_source) {
704                 udev_monitor_unref(master->udev_monitor);
705                 return 0;
706         }
707
708         return 1;
709 }
710
711 void
712 evdev_disable_udev_monitor(struct weston_seat *seat_base)
713 {
714         struct evdev_seat *seat = (struct evdev_seat *) seat_base;
715
716         if (!seat->udev_monitor)
717                 return;
718
719         udev_monitor_unref(seat->udev_monitor);
720         seat->udev_monitor = NULL;
721         wl_event_source_remove(seat->udev_monitor_source);
722         seat->udev_monitor_source = NULL;
723 }
724
725 void
726 evdev_input_create(struct weston_compositor *c, struct udev *udev,
727                    const char *seat_id)
728 {
729         struct evdev_seat *seat;
730
731         seat = malloc(sizeof *seat);
732         if (seat == NULL)
733                 return;
734
735         memset(seat, 0, sizeof *seat);
736         weston_seat_init(&seat->base, c);
737         seat->base.led_update = evdev_led_update;
738
739         wl_list_init(&seat->devices_list);
740         seat->seat_id = strdup(seat_id);
741         if (!evdev_enable_udev_monitor(udev, &seat->base)) {
742                 free(seat->seat_id);
743                 free(seat);
744                 return;
745         }
746
747         evdev_add_devices(udev, &seat->base);
748
749         c->seat = &seat->base;
750 }
751
752 void
753 evdev_remove_devices(struct weston_seat *seat_base)
754 {
755         struct evdev_seat *seat = (struct evdev_seat *) seat_base;
756         struct evdev_input_device *device, *next;
757
758         wl_list_for_each_safe(device, next, &seat->devices_list, link)
759                 device_removed(device);
760
761         notify_keyboard_focus(&seat->base.seat, NULL);
762 }
763
764 void
765 evdev_input_destroy(struct weston_seat *seat_base)
766 {
767         struct evdev_seat *seat = (struct evdev_seat *) seat_base;
768
769         evdev_remove_devices(seat_base);
770         evdev_disable_udev_monitor(&seat->base);
771
772         wl_list_remove(&seat->base.link);
773         free(seat->seat_id);
774         free(seat);
775 }