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 "config.h"
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <linux/input.h>
  28 #include <unistd.h>
  29 #include <fcntl.h>
  30 #include <mtdev.h>
  31 #include <assert.h>
  32
  33 #include "compositor.h"
  34 #include "evdev.h"
  35
  36 #define DEFAULT_AXIS_STEP_DISTANCE wl_fixed_from_int(10)
  37
  38 void
  39 evdev_led_update(struct evdev_device *device, enum weston_led leds)
  40 {
  41         static const struct {
  42                 enum weston_led weston;
  43                 int evdev;
  44         } map[] = {
  45                 { LED_NUM_LOCK, LED_NUML },
  46                 { LED_CAPS_LOCK, LED_CAPSL },
  47                 { LED_SCROLL_LOCK, LED_SCROLLL },
  48         };
  49         struct input_event ev[ARRAY_LENGTH(map) + 1];
  50         unsigned int i;
  51
  52         if (!device->caps & EVDEV_KEYBOARD)
  53                 return;
  54
  55         memset(ev, 0, sizeof(ev));
  56         for (i = 0; i < ARRAY_LENGTH(map); i++) {
  57                 ev[i].type = EV_LED;
  58                 ev[i].code = map[i].evdev;
  59                 ev[i].value = !!(leds & map[i].weston);
  60         }
  61         ev[i].type = EV_SYN;
  62         ev[i].code = SYN_REPORT;
  63
  64         i = write(device->fd, ev, sizeof ev);
  65         (void)i; /* no, we really don't care about the return value */
  66 }
  67
  68 static void
  69 transform_absolute(struct evdev_device *device, int32_t *x, int32_t *y)
  70 {
  71        if (!device->abs.apply_calibration) {
  72                *x = device->abs.x;
  73                *y = device->abs.y;
  74                return;
  75        } else {
  76                *x = device->abs.x * device->abs.calibration[0] +
  77                        device->abs.y * device->abs.calibration[1] +
  78                        device->abs.calibration[2];
  79
  80                *y = device->abs.x * device->abs.calibration[3] +
  81                        device->abs.y * device->abs.calibration[4] +
  82                        device->abs.calibration[5];
  83        }
  84 }
  85
  86 static void
  87 evdev_flush_pending_event(struct evdev_device *device, uint32_t time)
  88 {
  89         struct weston_seat *master = device->seat;
  90         wl_fixed_t x, y;
  91         int32_t cx, cy;
  92         int slot;
  93
  94         slot = device->mt.slot;
  95
  96         switch (device->pending_event) {
  97         case EVDEV_NONE:
  98                 return;
  99         case EVDEV_RELATIVE_MOTION:
 100                 notify_motion(master, time, device->rel.dx, device->rel.dy);
 101                 device->rel.dx = 0;
 102                 device->rel.dy = 0;
 103                 goto handled;
 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,
 108                                                    &x, &y);
 109                 notify_touch(master, time,
 110                              slot, x, y, WL_TOUCH_DOWN);
 111                 goto handled;
 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,
 116                                                    &x, &y);
 117                 notify_touch(master, time,
 118                              slot, x, y, WL_TOUCH_MOTION);
 119                 goto handled;
 120         case EVDEV_ABSOLUTE_MT_UP:
 121                 notify_touch(master, time, slot, 0, 0,
 122                              WL_TOUCH_UP);
 123                 goto handled;
 124         case EVDEV_ABSOLUTE_TOUCH_DOWN:
 125                 transform_absolute(device, &cx, &cy);
 126                 weston_output_transform_coordinate(device->output,
 127                                                    cx, cy, &x, &y);
 128                 notify_touch(master, time, 0, x, y, WL_TOUCH_DOWN);
 129                 goto handled;
 130         case EVDEV_ABSOLUTE_MOTION:
 131                 transform_absolute(device, &cx, &cy);
 132                 weston_output_transform_coordinate(device->output,
 133                                                    cx, cy, &x, &y);
 134
 135                 if (device->caps & EVDEV_TOUCH)
 136                         notify_touch(master, time, 0, x, y, WL_TOUCH_MOTION);
 137                 else
 138                         notify_motion_absolute(master, time, x, y);
 139                 goto handled;
 140         case EVDEV_ABSOLUTE_TOUCH_UP:
 141                 notify_touch(master, time, 0, 0, 0, WL_TOUCH_UP);
 142                 goto handled;
 143         }
 144
 145         assert(0 && "Unknown pending event type");
 146
 147 handled:
 148         device->pending_event = EVDEV_NONE;
 149 }
 150
 151 static void
 152 evdev_process_touch_button(struct evdev_device *device, int time, int value)
 153 {
 154         if (device->pending_event != EVDEV_NONE &&
 155             device->pending_event != EVDEV_ABSOLUTE_MOTION)
 156                 evdev_flush_pending_event(device, time);
 157
 158         device->pending_event = (value ?
 159                                  EVDEV_ABSOLUTE_TOUCH_DOWN :
 160                                  EVDEV_ABSOLUTE_TOUCH_UP);
 161 }
 162
 163 static inline void
 164 evdev_process_key(struct evdev_device *device, struct input_event *e, int time)
 165 {
 166         /* ignore kernel key repeat */
 167         if (e->value == 2)
 168                 return;
 169
 170         if (e->code == BTN_TOUCH) {
 171                 if (!device->is_mt)
 172                         evdev_process_touch_button(device, time, e->value);
 173                 return;
 174         }
 175
 176         evdev_flush_pending_event(device, time);
 177
 178         switch (e->code) {
 179         case BTN_LEFT:
 180         case BTN_RIGHT:
 181         case BTN_MIDDLE:
 182         case BTN_SIDE:
 183         case BTN_EXTRA:
 184         case BTN_FORWARD:
 185         case BTN_BACK:
 186         case BTN_TASK:
 187                 notify_button(device->seat,
 188                               time, e->code,
 189                               e->value ? WL_POINTER_BUTTON_STATE_PRESSED :
 190                                          WL_POINTER_BUTTON_STATE_RELEASED);
 191                 break;
 192
 193         default:
 194                 notify_key(device->seat,
 195                            time, e->code,
 196                            e->value ? WL_KEYBOARD_KEY_STATE_PRESSED :
 197                                       WL_KEYBOARD_KEY_STATE_RELEASED,
 198                            STATE_UPDATE_AUTOMATIC);
 199                 break;
 200         }
 201 }
 202
 203 static void
 204 evdev_process_touch(struct evdev_device *device,
 205                     struct input_event *e,
 206                     uint32_t time)
 207 {
 208         const int screen_width = device->output->current_mode->width;
 209         const int screen_height = device->output->current_mode->height;
 210
 211         switch (e->code) {
 212         case ABS_MT_SLOT:
 213                 evdev_flush_pending_event(device, time);
 214                 device->mt.slot = e->value;
 215                 break;
 216         case ABS_MT_TRACKING_ID:
 217                 if (device->pending_event != EVDEV_NONE &&
 218                     device->pending_event != EVDEV_ABSOLUTE_MT_MOTION)
 219                         evdev_flush_pending_event(device, time);
 220                 if (e->value >= 0)
 221                         device->pending_event = EVDEV_ABSOLUTE_MT_DOWN;
 222                 else
 223                         device->pending_event = EVDEV_ABSOLUTE_MT_UP;
 224                 break;
 225         case ABS_MT_POSITION_X:
 226                 device->mt.slots[device->mt.slot].x =
 227                         (e->value - device->abs.min_x) * screen_width /
 228                         (device->abs.max_x - device->abs.min_x);
 229                 if (device->pending_event == EVDEV_NONE)
 230                         device->pending_event = EVDEV_ABSOLUTE_MT_MOTION;
 231                 break;
 232         case ABS_MT_POSITION_Y:
 233                 device->mt.slots[device->mt.slot].y =
 234                         (e->value - device->abs.min_y) * screen_height /
 235                         (device->abs.max_y - device->abs.min_y);
 236                 if (device->pending_event == EVDEV_NONE)
 237                         device->pending_event = EVDEV_ABSOLUTE_MT_MOTION;
 238                 break;
 239         }
 240 }
 241
 242 static inline void
 243 evdev_process_absolute_motion(struct evdev_device *device,
 244                               struct input_event *e)
 245 {
 246         const int screen_width = device->output->current_mode->width;
 247         const int screen_height = device->output->current_mode->height;
 248
 249         switch (e->code) {
 250         case ABS_X:
 251                 device->abs.x =
 252                         (e->value - device->abs.min_x) * screen_width /
 253                         (device->abs.max_x - device->abs.min_x);
 254                 if (device->pending_event == EVDEV_NONE)
 255                         device->pending_event = EVDEV_ABSOLUTE_MOTION;
 256                 break;
 257         case ABS_Y:
 258                 device->abs.y =
 259                         (e->value - device->abs.min_y) * screen_height /
 260                         (device->abs.max_y - device->abs.min_y);
 261                 if (device->pending_event == EVDEV_NONE)
 262                         device->pending_event = EVDEV_ABSOLUTE_MOTION;
 263                 break;
 264         }
 265 }
 266
 267 static inline void
 268 evdev_process_relative(struct evdev_device *device,
 269                        struct input_event *e, uint32_t time)
 270 {
 271         switch (e->code) {
 272         case REL_X:
 273                 if (device->pending_event != EVDEV_RELATIVE_MOTION)
 274                         evdev_flush_pending_event(device, time);
 275                 device->rel.dx += wl_fixed_from_int(e->value);
 276                 device->pending_event = EVDEV_RELATIVE_MOTION;
 277                 break;
 278         case REL_Y:
 279                 if (device->pending_event != EVDEV_RELATIVE_MOTION)
 280                         evdev_flush_pending_event(device, time);
 281                 device->rel.dy += wl_fixed_from_int(e->value);
 282                 device->pending_event = EVDEV_RELATIVE_MOTION;
 283                 break;
 284         case REL_WHEEL:
 285                 evdev_flush_pending_event(device, time);
 286                 switch (e->value) {
 287                 case -1:
 288                         /* Scroll down */
 289                 case 1:
 290                         /* Scroll up */
 291                         notify_axis(device->seat,
 292                                     time,
 293                                     WL_POINTER_AXIS_VERTICAL_SCROLL,
 294                                     -1 * e->value * DEFAULT_AXIS_STEP_DISTANCE);
 295                         break;
 296                 default:
 297                         break;
 298                 }
 299                 break;
 300         case REL_HWHEEL:
 301                 evdev_flush_pending_event(device, time);
 302                 switch (e->value) {
 303                 case -1:
 304                         /* Scroll left */
 305                 case 1:
 306                         /* Scroll right */
 307                         notify_axis(device->seat,
 308                                     time,
 309                                     WL_POINTER_AXIS_HORIZONTAL_SCROLL,
 310                                     e->value * DEFAULT_AXIS_STEP_DISTANCE);
 311                         break;
 312                 default:
 313                         break;
 314
 315                 }
 316         }
 317 }
 318
 319 static inline void
 320 evdev_process_absolute(struct evdev_device *device,
 321                        struct input_event *e,
 322                        uint32_t time)
 323 {
 324         if (device->is_mt) {
 325                 evdev_process_touch(device, e, time);
 326         } else {
 327                 evdev_process_absolute_motion(device, e);
 328         }
 329 }
 330
 331 static void
 332 fallback_process(struct evdev_dispatch *dispatch,
 333                  struct evdev_device *device,
 334                  struct input_event *event,
 335                  uint32_t time)
 336 {
 337         switch (event->type) {
 338         case EV_REL:
 339                 evdev_process_relative(device, event, time);
 340                 break;
 341         case EV_ABS:
 342                 evdev_process_absolute(device, event, time);
 343                 break;
 344         case EV_KEY:
 345                 evdev_process_key(device, event, time);
 346                 break;
 347         case EV_SYN:
 348                 evdev_flush_pending_event(device, time);
 349                 break;
 350         }
 351 }
 352
 353 static void
 354 fallback_destroy(struct evdev_dispatch *dispatch)
 355 {
 356         free(dispatch);
 357 }
 358
 359 struct evdev_dispatch_interface fallback_interface = {
 360         fallback_process,
 361         fallback_destroy
 362 };
 363
 364 static struct evdev_dispatch *
 365 fallback_dispatch_create(void)
 366 {
 367         struct evdev_dispatch *dispatch = malloc(sizeof *dispatch);
 368         if (dispatch == NULL)
 369                 return NULL;
 370
 371         dispatch->interface = &fallback_interface;
 372
 373         return dispatch;
 374 }
 375
 376 static void
 377 evdev_process_events(struct evdev_device *device,
 378                      struct input_event *ev, int count)
 379 {
 380         struct evdev_dispatch *dispatch = device->dispatch;
 381         struct input_event *e, *end;
 382         uint32_t time = 0;
 383
 384         e = ev;
 385         end = e + count;
 386         for (e = ev; e < end; e++) {
 387                 time = e->time.tv_sec * 1000 + e->time.tv_usec / 1000;
 388
 389                 dispatch->interface->process(dispatch, device, e, time);
 390         }
 391 }
 392
 393 static int
 394 evdev_device_data(int fd, uint32_t mask, void *data)
 395 {
 396         struct weston_compositor *ec;
 397         struct evdev_device *device = data;
 398         struct input_event ev[32];
 399         int len;
 400
 401         ec = device->seat->compositor;
 402         if (!ec->focus)
 403                 return 1;
 404
 405         /* If the compositor is repainting, this function is called only once
 406          * per frame and we have to process all the events available on the
 407          * fd, otherwise there will be input lag. */
 408         do {
 409                 if (device->mtdev)
 410                         len = mtdev_get(device->mtdev, fd, ev,
 411                                         ARRAY_LENGTH(ev)) *
 412                                 sizeof (struct input_event);
 413                 else
 414                         len = read(fd, &ev, sizeof ev);
 415
 416                 if (len < 0 || len % sizeof ev[0] != 0) {
 417                         /* FIXME: call evdev_device_destroy when errno is ENODEV. */
 418                         return 1;
 419                 }
 420
 421                 evdev_process_events(device, ev, len / sizeof ev[0]);
 422
 423         } while (len > 0);
 424
 425         return 1;
 426 }
 427
 428 static int
 429 evdev_handle_device(struct evdev_device *device)
 430 {
 431         struct input_absinfo absinfo;
 432         unsigned long ev_bits[NBITS(EV_MAX)];
 433         unsigned long abs_bits[NBITS(ABS_MAX)];
 434         unsigned long rel_bits[NBITS(REL_MAX)];
 435         unsigned long key_bits[NBITS(KEY_MAX)];
 436         int has_key, has_abs;
 437         unsigned int i;
 438
 439         has_key = 0;
 440         has_abs = 0;
 441         device->caps = 0;
 442
 443         ioctl(device->fd, EVIOCGBIT(0, sizeof(ev_bits)), ev_bits);
 444         if (TEST_BIT(ev_bits, EV_ABS)) {
 445                 has_abs = 1;
 446
 447                 ioctl(device->fd, EVIOCGBIT(EV_ABS, sizeof(abs_bits)),
 448                       abs_bits);
 449
 450                 if (TEST_BIT(abs_bits, ABS_WHEEL) ||
 451                     TEST_BIT(abs_bits, ABS_GAS) ||
 452                     TEST_BIT(abs_bits, ABS_BRAKE) ||
 453                     TEST_BIT(abs_bits, ABS_HAT0X)) {
 454                         weston_log("device %s is a joystick, ignoring\n",
 455                                    device->devnode);
 456                         return 0;
 457                 }
 458
 459                 if (TEST_BIT(abs_bits, ABS_X)) {
 460                         ioctl(device->fd, EVIOCGABS(ABS_X), &absinfo);
 461                         device->abs.min_x = absinfo.minimum;
 462                         device->abs.max_x = absinfo.maximum;
 463                         device->caps |= EVDEV_MOTION_ABS;
 464                 }
 465                 if (TEST_BIT(abs_bits, ABS_Y)) {
 466                         ioctl(device->fd, EVIOCGABS(ABS_Y), &absinfo);
 467                         device->abs.min_y = absinfo.minimum;
 468                         device->abs.max_y = absinfo.maximum;
 469                         device->caps |= EVDEV_MOTION_ABS;
 470                 }
 471                 /* We only handle the slotted Protocol B in weston.
 472                    Devices with ABS_MT_POSITION_* but not ABS_MT_SLOT
 473                    require mtdev for conversion. */
 474                 if (TEST_BIT(abs_bits, ABS_MT_POSITION_X) &&
 475                     TEST_BIT(abs_bits, ABS_MT_POSITION_Y)) {
 476                         ioctl(device->fd, EVIOCGABS(ABS_MT_POSITION_X),
 477                               &absinfo);
 478                         device->abs.min_x = absinfo.minimum;
 479                         device->abs.max_x = absinfo.maximum;
 480                         ioctl(device->fd, EVIOCGABS(ABS_MT_POSITION_Y),
 481                               &absinfo);
 482                         device->abs.min_y = absinfo.minimum;
 483                         device->abs.max_y = absinfo.maximum;
 484                         device->is_mt = 1;
 485                         device->caps |= EVDEV_TOUCH;
 486
 487                         if (!TEST_BIT(abs_bits, ABS_MT_SLOT)) {
 488                                 device->mtdev = mtdev_new_open(device->fd);
 489                                 if (!device->mtdev) {
 490                                         weston_log("mtdev required but failed to open for %s\n",
 491                                                    device->devnode);
 492                                         return 0;
 493                                 }
 494                                 device->mt.slot = device->mtdev->caps.slot.value;
 495                         } else {
 496                                 ioctl(device->fd, EVIOCGABS(ABS_MT_SLOT),
 497                                       &absinfo);
 498                                 device->mt.slot = absinfo.value;
 499                         }
 500                 }
 501         }
 502         if (TEST_BIT(ev_bits, EV_REL)) {
 503                 ioctl(device->fd, EVIOCGBIT(EV_REL, sizeof(rel_bits)),
 504                       rel_bits);
 505                 if (TEST_BIT(rel_bits, REL_X) || TEST_BIT(rel_bits, REL_Y))
 506                         device->caps |= EVDEV_MOTION_REL;
 507         }
 508         if (TEST_BIT(ev_bits, EV_KEY)) {
 509                 has_key = 1;
 510                 ioctl(device->fd, EVIOCGBIT(EV_KEY, sizeof(key_bits)),
 511                       key_bits);
 512                 if (TEST_BIT(key_bits, BTN_TOOL_FINGER) &&
 513                     !TEST_BIT(key_bits, BTN_TOOL_PEN) &&
 514                     has_abs) {
 515                         device->dispatch = evdev_touchpad_create(device);
 516                         weston_log("input device %s, %s is a touchpad\n",
 517                                    device->devname, device->devnode);
 518                 }
 519                 for (i = KEY_ESC; i < KEY_MAX; i++) {
 520                         if (i >= BTN_MISC && i < KEY_OK)
 521                                 continue;
 522                         if (TEST_BIT(key_bits, i)) {
 523                                 device->caps |= EVDEV_KEYBOARD;
 524                                 break;
 525                         }
 526                 }
 527                 for (i = BTN_MISC; i < BTN_JOYSTICK; i++) {
 528                         if (TEST_BIT(key_bits, i)) {
 529                                 device->caps |= EVDEV_BUTTON;
 530                                 break;
 531                         }
 532                 }
 533                 if (TEST_BIT(key_bits, BTN_TOUCH)) {
 534                         device->caps |= EVDEV_TOUCH;
 535                 }
 536
 537         }
 538         if (TEST_BIT(ev_bits, EV_LED)) {
 539                 device->caps |= EVDEV_KEYBOARD;
 540         }
 541
 542         /* This rule tries to catch accelerometer devices and opt out. We may
 543          * want to adjust the protocol later adding a proper event for dealing
 544          * with accelerometers and implement here accordingly */
 545         if (has_abs && !has_key && !device->is_mt) {
 546                 weston_log("input device %s, %s "
 547                            "ignored: unsupported device type\n",
 548                            device->devname, device->devnode);
 549                 return 0;
 550         }
 551
 552         return 1;
 553 }
 554
 555 static int
 556 evdev_configure_device(struct evdev_device *device)
 557 {
 558         if ((device->caps &
 559              (EVDEV_MOTION_ABS | EVDEV_MOTION_REL | EVDEV_BUTTON))) {
 560                 weston_seat_init_pointer(device->seat);
 561                 weston_log("input device %s, %s is a pointer caps =%s%s%s\n",
 562                            device->devname, device->devnode,
 563                            device->caps & EVDEV_MOTION_ABS ? " absolute-motion" : "",
 564                            device->caps & EVDEV_MOTION_REL ? " relative-motion": "",
 565                            device->caps & EVDEV_BUTTON ? " button" : "");
 566         }
 567         if ((device->caps & EVDEV_KEYBOARD)) {
 568                 if (weston_seat_init_keyboard(device->seat, NULL) < 0)
 569                         return -1;
 570                 weston_log("input device %s, %s is a keyboard\n",
 571                            device->devname, device->devnode);
 572         }
 573         if ((device->caps & EVDEV_TOUCH)) {
 574                 weston_seat_init_touch(device->seat);
 575                 weston_log("input device %s, %s is a touch device\n",
 576                            device->devname, device->devnode);
 577         }
 578
 579         return 0;
 580 }
 581
 582 struct evdev_device *
 583 evdev_device_create(struct weston_seat *seat, const char *path, int device_fd)
 584 {
 585         struct evdev_device *device;
 586         struct weston_compositor *ec;
 587         char devname[256] = "unknown";
 588
 589         device = zalloc(sizeof *device);
 590         if (device == NULL)
 591                 return NULL;
 592
 593         ec = seat->compositor;
 594         device->output =
 595                 container_of(ec->output_list.next, struct weston_output, link);
 596
 597         device->seat = seat;
 598         device->is_mt = 0;
 599         device->mtdev = NULL;
 600         device->devnode = strdup(path);
 601         device->mt.slot = -1;
 602         device->rel.dx = 0;
 603         device->rel.dy = 0;
 604         device->dispatch = NULL;
 605         device->fd = device_fd;
 606         device->pending_event = EVDEV_NONE;
 607         wl_list_init(&device->link);
 608
 609         ioctl(device->fd, EVIOCGNAME(sizeof(devname)), devname);
 610         devname[sizeof(devname) - 1] = '\0';
 611         device->devname = strdup(devname);
 612
 613         if (!evdev_handle_device(device)) {
 614                 evdev_device_destroy(device);
 615                 return EVDEV_UNHANDLED_DEVICE;
 616         }
 617
 618         if (evdev_configure_device(device) == -1)
 619                 goto err;
 620
 621         /* If the dispatch was not set up use the fallback. */
 622         if (device->dispatch == NULL)
 623                 device->dispatch = fallback_dispatch_create();
 624         if (device->dispatch == NULL)
 625                 goto err;
 626
 627         device->source = wl_event_loop_add_fd(ec->input_loop, device->fd,
 628                                               WL_EVENT_READABLE,
 629                                               evdev_device_data, device);
 630         if (device->source == NULL)
 631                 goto err;
 632
 633         return device;
 634
 635 err:
 636         evdev_device_destroy(device);
 637         return NULL;
 638 }
 639
 640 void
 641 evdev_device_destroy(struct evdev_device *device)
 642 {
 643         struct evdev_dispatch *dispatch;
 644
 645         dispatch = device->dispatch;
 646         if (dispatch)
 647                 dispatch->interface->destroy(dispatch);
 648
 649         if (device->source)
 650                 wl_event_source_remove(device->source);
 651         wl_list_remove(&device->link);
 652         if (device->mtdev)
 653                 mtdev_close_delete(device->mtdev);
 654         close(device->fd);
 655         free(device->devname);
 656         free(device->devnode);
 657         free(device);
 658 }
 659
 660 void
 661 evdev_notify_keyboard_focus(struct weston_seat *seat,
 662                             struct wl_list *evdev_devices)
 663 {
 664         struct evdev_device *device;
 665         struct wl_array keys;
 666         unsigned int i, set;
 667         char evdev_keys[(KEY_CNT + 7) / 8];
 668         char all_keys[(KEY_CNT + 7) / 8];
 669         uint32_t *k;
 670         int ret;
 671
 672         if (!seat->keyboard)
 673                 return;
 674
 675         memset(all_keys, 0, sizeof all_keys);
 676         wl_list_for_each(device, evdev_devices, link) {
 677                 memset(evdev_keys, 0, sizeof evdev_keys);
 678                 ret = ioctl(device->fd,
 679                             EVIOCGKEY(sizeof evdev_keys), evdev_keys);
 680                 if (ret < 0) {
 681                         weston_log("failed to get keys for device %s\n",
 682                                 device->devnode);
 683                         continue;
 684                 }
 685                 for (i = 0; i < ARRAY_LENGTH(evdev_keys); i++)
 686                         all_keys[i] |= evdev_keys[i];
 687         }
 688
 689         wl_array_init(&keys);
 690         for (i = 0; i < KEY_CNT; i++) {
 691                 set = all_keys[i >> 3] & (1 << (i & 7));
 692                 if (set) {
 693                         k = wl_array_add(&keys, sizeof *k);
 694                         *k = i;
 695                 }
 696         }
 697
 698         notify_keyboard_focus_in(seat, &keys, STATE_UPDATE_AUTOMATIC);
 699
 700         wl_array_release(&keys);
 701 }