src/lib/evdev/evdev.c

   1 /*
   2 * Copyright © 2015-2017 Samsung Electronics co., Ltd. All Rights Reserved.
   3 *
   4 * Permission is hereby granted, free of charge, to any person obtaining a
   5 * copy of this software and associated documentation files (the "Software"),
   6 * to deal in the Software without restriction, including without limitation
   7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 * and/or sell copies of the Software, and to permit persons to whom the
   9 * Software is furnished to do so, subject to the following conditions:
  10 *
  11 * The above copyright notice and this permission notice (including the next
  12 * paragraph) shall be included in all copies or substantial portions of the
  13 * Software.
  14 *
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21 * DEALINGS IN THE SOFTWARE.
  22 */
  23
  24 #define _GNU_SOURCE
  25
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <fcntl.h>
  29 #include <unistd.h>
  30 #include <string.h>
  31 #include <errno.h>
  32 #include <stdint.h>
  33 #include <dirent.h>
  34 #include <stdlib.h>
  35 #include <stdio.h>
  36 #include <linux/input.h>
  37
  38 #include <evdev-internal.h>
  39 #include <pepper-input-backend.h>
  40
  41 #ifdef EVENT_MAX
  42 #undef EVENT_MAX
  43 #endif
  44 #define EVENT_MAX 32
  45
  46 #ifndef LONG_BITS
  47 #define LONG_BITS (sizeof(long) * 8)
  48 #endif
  49
  50 #ifndef NLONGS
  51 #define NLONGS(x) (((x) + LONG_BITS - 1) / LONG_BITS)
  52 #endif
  53
  54 static void
  55 _evdev_keyboard_event_post(pepper_input_device_t *device, uint32_t keycode, int state, uint32_t time)
  56 {
  57         pepper_input_event_t event;
  58
  59         event.time = time;
  60         event.key = keycode;
  61         event.state = state ? PEPPER_KEY_STATE_PRESSED : PEPPER_KEY_STATE_RELEASED;
  62
  63         pepper_object_emit_event((pepper_object_t *)device,
  64                                                                 PEPPER_EVENT_INPUT_DEVICE_KEYBOARD_KEY, &event);
  65 }
  66
  67 static void
  68 _evdev_keyboard_event_flush(pepper_evdev_t *evdev)
  69 {
  70         evdev_key_event_t *event = NULL;
  71         evdev_key_event_t *tmp = NULL;
  72
  73         pepper_list_for_each_safe(event, tmp, &evdev->key_event_queue, link)
  74         {
  75                 _evdev_keyboard_event_post(event->device, event->keycode, event->state, event->time);
  76                 pepper_list_remove(&event->link);
  77                 free(event);
  78         }
  79 }
  80
  81 static void
  82 _evdev_keyboard_event_queue(uint32_t keycode, int state, uint32_t time, evdev_device_info_t *device_info)
  83 {
  84         evdev_key_event_t *event = NULL;
  85         pepper_evdev_t *evdev = device_info->evdev;
  86
  87         event = (evdev_key_event_t *)calloc(1, sizeof(evdev_key_event_t));
  88         PEPPER_CHECK(event, return, "[%s] Failed to allocate memory for key event.\n", __FUNCTION__);
  89
  90         event->keycode = keycode;
  91         event->state = state;
  92         event->time = time;
  93         event->device = device_info->device;
  94
  95         pepper_list_insert(&evdev->key_event_queue, &event->link);
  96 }
  97
  98 static void
  99 _evdev_keyboard_event_process(struct input_event *ev, evdev_device_info_t *device_info)
 100 {
 101          uint32_t timestamp;
 102
 103         /* FIXME : need to think about using current time vs. time within event from kernel */
 104         timestamp = ev->time.tv_sec * 1000 + ev->time.tv_usec / 1000;
 105
 106         switch (ev->type)
 107         {
 108                 case EV_KEY:
 109                         _evdev_keyboard_event_queue((uint32_t)ev->code, ev->value, timestamp, device_info);
 110                         break;
 111
 112                 case EV_SYN:
 113                         _evdev_keyboard_event_flush(device_info->evdev);
 114                         break;
 115
 116                 default:
 117                         break;
 118         }
 119 }
 120
 121 static int
 122 _evdev_keyboard_event_fd_read(int fd, uint32_t mask, void *data)
 123 {
 124         uint32_t i;
 125         int nread;
 126         char buf[128];
 127         struct input_event ev[EVENT_MAX];
 128         evdev_device_info_t *device_info = (evdev_device_info_t *)data;
 129
 130         PEPPER_CHECK(!(mask & (WL_EVENT_HANGUP | WL_EVENT_ERROR)),
 131                                         return 0,
 132                                         "[%s] With the given fd, there is an error or it's been hung-up.\n",
 133                                         __FUNCTION__);
 134
 135         if (!(mask & WL_EVENT_READABLE))
 136                 return 0;
 137
 138         nread = read(fd, &ev, sizeof(ev));
 139         PEPPER_CHECK(nread>=0, return 0, "[%s] Failed on reading given fd. (error : %s, fd:%d)\n",
 140                                         __FUNCTION__, strerror_r(errno, buf, 128), fd);
 141
 142         for (i = 0 ; i < (nread / sizeof(ev[0])); i++)
 143         {
 144                 _evdev_keyboard_event_process(&ev[i], device_info);
 145         }
 146
 147         return 0;
 148 }
 149
 150 static int
 151 bit_is_set(const unsigned long *array, int bit)
 152 {
 153     return !!(array[bit / LONG_BITS] & (1LL << (bit % LONG_BITS)));
 154 }
 155
 156 static void
 157 _evdev_device_configure(evdev_device_info_t *device_info)
 158 {
 159         int rc;
 160         unsigned long bits[NLONGS(EV_CNT)] = {0, };
 161         unsigned long key_bits[NLONGS(KEY_CNT)] = {0, };
 162         unsigned long found = 0, i;
 163         char device_name[256] = {0, };
 164
 165         rc = ioctl(device_info->fd, EVIOCGBIT(0, sizeof(bits)), bits);
 166         PEPPER_CHECK(rc >= 0, return, "Failed to get event bits\n");
 167
 168         if (bit_is_set(bits, EV_KEY)) {
 169                 rc = ioctl(device_info->fd, EVIOCGBIT(EV_KEY, sizeof(key_bits)), key_bits);
 170                 if (rc >= 0) {
 171                         for (i = 0; i < BTN_MISC / BITS_PER_LONG; ++i) {
 172                                 found |= key_bits[i];
 173                                 if (found) break;
 174                         }
 175                         if (!found) {
 176                                 for (i = KEY_OK; i < BTN_TRIGGER_HAPPY; ++i) {
 177                                         if (bit_is_set(key_bits, i)) {
 178                                                 found = 1;
 179                                                 break;
 180                                         }
 181                                 }
 182                         }
 183
 184                         if (found) device_info->caps |= WL_SEAT_CAPABILITY_KEYBOARD;
 185                 } else
 186                         PEPPER_ERROR("Failed to get key bits\n");
 187         }
 188
 189         if (bit_is_set(bits, EV_REL)) {
 190                 rc = ioctl(device_info->fd, EVIOCGNAME(sizeof(device_name) - 1), device_name);
 191                 if (rc >= 0) {
 192                         if (strcasestr(device_name, "mouse"))
 193                                 device_info->caps |= WL_SEAT_CAPABILITY_POINTER;
 194                 } else
 195                         PEPPER_ERROR("Failed to get device name\n");
 196         }
 197 }
 198
 199 static int
 200 _evdev_keyboard_device_open(pepper_evdev_t *evdev, const char *path)
 201 {
 202         int fd;
 203         char device_path[32];
 204         uint32_t event_mask;
 205         evdev_device_info_t *device_info = NULL;
 206         pepper_input_device_t *device = NULL;
 207
 208         PEPPER_CHECK(path, return 0, "[%s] Given path is NULL.\n", __FUNCTION__);
 209
 210         snprintf(device_path, sizeof(device_path), "/dev/input/%s", path);
 211
 212         fd = open(device_path, O_RDONLY | O_NONBLOCK | O_CLOEXEC);
 213         PEPPER_CHECK(fd >= 0, return 0, "[%s] Failed to open given path of device.\n", __FUNCTION__);
 214
 215         device_info = (evdev_device_info_t *)calloc(1, sizeof(evdev_device_info_t));
 216         PEPPER_CHECK(device_info, goto error, "[%s] Failed to allocate memory for device info...\n", __FUNCTION__);
 217
 218         device_info->fd = fd;
 219         device_info->evdev = evdev;
 220         strncpy(device_info->path, path, MAX_PATH_LEN - 1);
 221
 222         _evdev_device_configure(device_info);
 223         if (device_info->caps != WL_SEAT_CAPABILITY_KEYBOARD) goto error;
 224
 225         device = pepper_input_device_create(evdev->compositor, WL_SEAT_CAPABILITY_KEYBOARD, NULL, NULL);
 226         PEPPER_CHECK(device, goto error, "[%s] Failed to create pepper input device.\n", __FUNCTION__);
 227
 228         device_info->device = device;
 229         event_mask = WL_EVENT_READABLE;
 230         device_info->event_source = wl_event_loop_add_fd(evdev->event_loop,
 231                         fd, event_mask, _evdev_keyboard_event_fd_read, device_info);
 232         PEPPER_CHECK(device_info->event_source, goto error, "[%s] Failed to add fd as an event source...\n", __FUNCTION__);
 233
 234         pepper_list_insert(&evdev->device_list, &device_info->link);
 235
 236         return 1;
 237
 238 error:
 239         if (device)
 240         {
 241                 pepper_input_device_destroy(device);
 242                 device = NULL;
 243         }
 244
 245         if (device_info)
 246         {
 247                 if (device_info->event_source)
 248                         wl_event_source_remove(device_info->event_source);
 249
 250                 free(device_info);
 251                 device_info = NULL;
 252         }
 253
 254         if (fd >=0)
 255                 close(fd);
 256
 257         return 0;
 258 }
 259
 260 static void
 261 _evdev_keyboard_device_close(pepper_evdev_t *evdev, const char *path)
 262 {
 263         evdev_device_info_t *device_info = NULL;
 264
 265         evdev_device_info_t *tmp = NULL;
 266
 267         PEPPER_CHECK(path, return, "[%s] Given path is NULL.\n", __FUNCTION__);
 268
 269         pepper_list_for_each_safe(device_info, tmp, &evdev->device_list, link) {
 270                 if (!strncmp(path, device_info->path, MAX_PATH_LEN)) {
 271                         pepper_input_device_destroy(device_info->device);
 272                         wl_event_source_remove(device_info->event_source);
 273                         close(device_info->fd);
 274
 275                         pepper_list_remove(&device_info->link);
 276                         free(device_info);
 277
 278                         break;
 279                 }
 280         }
 281 }
 282
 283
 284 PEPPER_API pepper_bool_t
 285 pepper_evdev_device_path_add(pepper_evdev_t *evdev, const char *path)
 286 {
 287         int res = 0;
 288
 289         PEPPER_CHECK(evdev, return PEPPER_FALSE, "Invalid evdev structure.\n");
 290         PEPPER_CHECK(path, return PEPPER_FALSE, "Invalid path.\n");
 291
 292         if (!strncmp(path, "event", 5)) {
 293                 res = _evdev_keyboard_device_open(evdev, path);
 294         } else {
 295                 PEPPER_ERROR("Invalid path to open: %s\n", path);
 296         }
 297
 298         if (res) return PEPPER_TRUE;
 299         return PEPPER_FALSE;
 300 }
 301
 302 PEPPER_API void
 303 pepper_evdev_device_path_remove(pepper_evdev_t *evdev, const char *path)
 304 {
 305         PEPPER_CHECK(evdev, return, "Invalid evdev structure.\n");
 306         PEPPER_CHECK(path, return, "Invalid path.\n");
 307
 308         if (!strncmp(path, "event", 5)) {
 309                 _evdev_keyboard_device_close(evdev, path);
 310         } else {
 311                 PEPPER_ERROR("Invalid path to close: %s\n", path);
 312         }
 313 }
 314
 315 PEPPER_API uint32_t
 316 pepper_evdev_device_probe(pepper_evdev_t *evdev, uint32_t caps)
 317 {
 318         uint32_t probed = 0;
 319
 320         DIR *dir_info = NULL;
 321         struct dirent *dir_entry = NULL;
 322
 323         /* Probe event device nodes under /dev/input */
 324         dir_info = opendir("/dev/input/");
 325
 326         if (dir_info)
 327         {
 328                 while ((dir_entry = readdir(dir_info)))
 329                 {
 330                         if (!strncmp(dir_entry->d_name, "event", 5))
 331                         {
 332                                 if (caps & WL_SEAT_CAPABILITY_KEYBOARD)
 333                                         probed += _evdev_keyboard_device_open(evdev, dir_entry->d_name);
 334                         }
 335                 }
 336
 337                 closedir(dir_info);
 338                 dir_info = NULL;
 339         }
 340
 341         return probed;
 342 }
 343
 344 PEPPER_API pepper_evdev_t *
 345 pepper_evdev_create(pepper_compositor_t *compositor)
 346 {
 347         pepper_evdev_t *evdev = NULL;
 348
 349         evdev = (pepper_evdev_t *)calloc(1, sizeof(pepper_evdev_t));
 350         PEPPER_CHECK(evdev, return NULL, "[%s] Failed to allocate memory for pepper evdev...\n", __FUNCTION__);
 351
 352         evdev->compositor = compositor;
 353         evdev->display = pepper_compositor_get_display(compositor);
 354         evdev->event_loop = wl_display_get_event_loop(evdev->display);
 355
 356         pepper_list_init(&evdev->device_list);
 357         pepper_list_init(&evdev->key_event_queue);
 358
 359         return evdev;
 360 }
 361
 362 PEPPER_API void
 363 pepper_evdev_destroy(pepper_evdev_t *evdev)
 364 {
 365         evdev_device_info_t *device_info = NULL;
 366         evdev_device_info_t *tmp = NULL;
 367
 368         if (!evdev)
 369                 return;
 370
 371         /* clean-up/destroy key event queue */
 372         if (!pepper_list_empty(&evdev->key_event_queue))
 373         {
 374                 _evdev_keyboard_event_flush(evdev);
 375                 pepper_list_remove(&evdev->key_event_queue);
 376         }
 377
 378         /* clean-up/destory device list */
 379         if (!pepper_list_empty(&evdev->device_list))
 380         {
 381                 pepper_list_for_each_safe(device_info, tmp, &evdev->device_list, link)
 382                 {
 383                         if (device_info->device)
 384                                 pepper_input_device_destroy(device_info->device);
 385                         if (device_info->event_source)
 386                                 wl_event_source_remove(device_info->event_source);
 387                         if (device_info->fd)
 388                                 close(device_info->fd);
 389
 390                         pepper_list_remove(&device_info->link);
 391                         free(device_info);
 392                 }
 393
 394                 pepper_list_remove(&evdev->device_list);
 395         }
 396
 397         free(evdev);
 398 }
 399