linux/samples/uhid/uhid-example.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * UHID Example
   4 *
   5 * Copyright (c) 2012-2013 David Herrmann <dh.herrmann@gmail.com>
   6 *
   7 * The code may be used by anyone for any purpose,
   8 * and can serve as a starting point for developing
   9 * applications using uhid.
  10 */
  11
  12/*
  13 * UHID Example
  14 * This example emulates a basic 3 buttons mouse with wheel over UHID. Run this
  15 * program as root and then use the following keys to control the mouse:
  16 *   q: Quit the application
  17 *   1: Toggle left button (down, up, ...)
  18 *   2: Toggle right button
  19 *   3: Toggle middle button
  20 *   a: Move mouse left
  21 *   d: Move mouse right
  22 *   w: Move mouse up
  23 *   s: Move mouse down
  24 *   r: Move wheel up
  25 *   f: Move wheel down
  26 *
  27 * Additionally to 3 button mouse, 3 keyboard LEDs are also supported (LED_NUML,
  28 * LED_CAPSL and LED_SCROLLL). The device doesn't generate any related keyboard
  29 * events, though. You need to manually write the EV_LED/LED_XY/1 activation
  30 * input event to the evdev device to see it being sent to this device.
  31 *
  32 * If uhid is not available as /dev/uhid, then you can pass a different path as
  33 * first argument.
  34 * If <linux/uhid.h> is not installed in /usr, then compile this with:
  35 *   gcc -o ./uhid_test -Wall -I./include ./samples/uhid/uhid-example.c
  36 * And ignore the warning about kernel headers. However, it is recommended to
  37 * use the installed uhid.h if available.
  38 */
  39
  40#include <errno.h>
  41#include <fcntl.h>
  42#include <poll.h>
  43#include <stdbool.h>
  44#include <stdio.h>
  45#include <stdlib.h>
  46#include <string.h>
  47#include <termios.h>
  48#include <unistd.h>
  49#include <linux/uhid.h>
  50
  51/*
  52 * HID Report Desciptor
  53 * We emulate a basic 3 button mouse with wheel and 3 keyboard LEDs. This is
  54 * the report-descriptor as the kernel will parse it:
  55 *
  56 * INPUT(1)[INPUT]
  57 *   Field(0)
  58 *     Physical(GenericDesktop.Pointer)
  59 *     Application(GenericDesktop.Mouse)
  60 *     Usage(3)
  61 *       Button.0001
  62 *       Button.0002
  63 *       Button.0003
  64 *     Logical Minimum(0)
  65 *     Logical Maximum(1)
  66 *     Report Size(1)
  67 *     Report Count(3)
  68 *     Report Offset(0)
  69 *     Flags( Variable Absolute )
  70 *   Field(1)
  71 *     Physical(GenericDesktop.Pointer)
  72 *     Application(GenericDesktop.Mouse)
  73 *     Usage(3)
  74 *       GenericDesktop.X
  75 *       GenericDesktop.Y
  76 *       GenericDesktop.Wheel
  77 *     Logical Minimum(-128)
  78 *     Logical Maximum(127)
  79 *     Report Size(8)
  80 *     Report Count(3)
  81 *     Report Offset(8)
  82 *     Flags( Variable Relative )
  83 * OUTPUT(2)[OUTPUT]
  84 *   Field(0)
  85 *     Application(GenericDesktop.Keyboard)
  86 *     Usage(3)
  87 *       LED.NumLock
  88 *       LED.CapsLock
  89 *       LED.ScrollLock
  90 *     Logical Minimum(0)
  91 *     Logical Maximum(1)
  92 *     Report Size(1)
  93 *     Report Count(3)
  94 *     Report Offset(0)
  95 *     Flags( Variable Absolute )
  96 *
  97 * This is the mapping that we expect:
  98 *   Button.0001 ---> Key.LeftBtn
  99 *   Button.0002 ---> Key.RightBtn
 100 *   Button.0003 ---> Key.MiddleBtn
 101 *   GenericDesktop.X ---> Relative.X
 102 *   GenericDesktop.Y ---> Relative.Y
 103 *   GenericDesktop.Wheel ---> Relative.Wheel
 104 *   LED.NumLock ---> LED.NumLock
 105 *   LED.CapsLock ---> LED.CapsLock
 106 *   LED.ScrollLock ---> LED.ScrollLock
 107 *
 108 * This information can be verified by reading /sys/kernel/debug/hid/<dev>/rdesc
 109 * This file should print the same information as showed above.
 110 */
 111
 112static unsigned char rdesc[] = {
 113        0x05, 0x01,     /* USAGE_PAGE (Generic Desktop) */
 114        0x09, 0x02,     /* USAGE (Mouse) */
 115        0xa1, 0x01,     /* COLLECTION (Application) */
 116        0x09, 0x01,             /* USAGE (Pointer) */
 117        0xa1, 0x00,             /* COLLECTION (Physical) */
 118        0x85, 0x01,                     /* REPORT_ID (1) */
 119        0x05, 0x09,                     /* USAGE_PAGE (Button) */
 120        0x19, 0x01,                     /* USAGE_MINIMUM (Button 1) */
 121        0x29, 0x03,                     /* USAGE_MAXIMUM (Button 3) */
 122        0x15, 0x00,                     /* LOGICAL_MINIMUM (0) */
 123        0x25, 0x01,                     /* LOGICAL_MAXIMUM (1) */
 124        0x95, 0x03,                     /* REPORT_COUNT (3) */
 125        0x75, 0x01,                     /* REPORT_SIZE (1) */
 126        0x81, 0x02,                     /* INPUT (Data,Var,Abs) */
 127        0x95, 0x01,                     /* REPORT_COUNT (1) */
 128        0x75, 0x05,                     /* REPORT_SIZE (5) */
 129        0x81, 0x01,                     /* INPUT (Cnst,Var,Abs) */
 130        0x05, 0x01,                     /* USAGE_PAGE (Generic Desktop) */
 131        0x09, 0x30,                     /* USAGE (X) */
 132        0x09, 0x31,                     /* USAGE (Y) */
 133        0x09, 0x38,                     /* USAGE (WHEEL) */
 134        0x15, 0x81,                     /* LOGICAL_MINIMUM (-127) */
 135        0x25, 0x7f,                     /* LOGICAL_MAXIMUM (127) */
 136        0x75, 0x08,                     /* REPORT_SIZE (8) */
 137        0x95, 0x03,                     /* REPORT_COUNT (3) */
 138        0x81, 0x06,                     /* INPUT (Data,Var,Rel) */
 139        0xc0,                   /* END_COLLECTION */
 140        0xc0,           /* END_COLLECTION */
 141        0x05, 0x01,     /* USAGE_PAGE (Generic Desktop) */
 142        0x09, 0x06,     /* USAGE (Keyboard) */
 143        0xa1, 0x01,     /* COLLECTION (Application) */
 144        0x85, 0x02,             /* REPORT_ID (2) */
 145        0x05, 0x08,             /* USAGE_PAGE (Led) */
 146        0x19, 0x01,             /* USAGE_MINIMUM (1) */
 147        0x29, 0x03,             /* USAGE_MAXIMUM (3) */
 148        0x15, 0x00,             /* LOGICAL_MINIMUM (0) */
 149        0x25, 0x01,             /* LOGICAL_MAXIMUM (1) */
 150        0x95, 0x03,             /* REPORT_COUNT (3) */
 151        0x75, 0x01,             /* REPORT_SIZE (1) */
 152        0x91, 0x02,             /* Output (Data,Var,Abs) */
 153        0x95, 0x01,             /* REPORT_COUNT (1) */
 154        0x75, 0x05,             /* REPORT_SIZE (5) */
 155        0x91, 0x01,             /* Output (Cnst,Var,Abs) */
 156        0xc0,           /* END_COLLECTION */
 157};
 158
 159static int uhid_write(int fd, const struct uhid_event *ev)
 160{
 161        ssize_t ret;
 162
 163        ret = write(fd, ev, sizeof(*ev));
 164        if (ret < 0) {
 165                fprintf(stderr, "Cannot write to uhid: %m\n");
 166                return -errno;
 167        } else if (ret != sizeof(*ev)) {
 168                fprintf(stderr, "Wrong size written to uhid: %ld != %lu\n",
 169                        ret, sizeof(ev));
 170                return -EFAULT;
 171        } else {
 172                return 0;
 173        }
 174}
 175
 176static int create(int fd)
 177{
 178        struct uhid_event ev;
 179
 180        memset(&ev, 0, sizeof(ev));
 181        ev.type = UHID_CREATE;
 182        strcpy((char*)ev.u.create.name, "test-uhid-device");
 183        ev.u.create.rd_data = rdesc;
 184        ev.u.create.rd_size = sizeof(rdesc);
 185        ev.u.create.bus = BUS_USB;
 186        ev.u.create.vendor = 0x15d9;
 187        ev.u.create.product = 0x0a37;
 188        ev.u.create.version = 0;
 189        ev.u.create.country = 0;
 190
 191        return uhid_write(fd, &ev);
 192}
 193
 194static void destroy(int fd)
 195{
 196        struct uhid_event ev;
 197
 198        memset(&ev, 0, sizeof(ev));
 199        ev.type = UHID_DESTROY;
 200
 201        uhid_write(fd, &ev);
 202}
 203
 204/* This parses raw output reports sent by the kernel to the device. A normal
 205 * uhid program shouldn't do this but instead just forward the raw report.
 206 * However, for ducomentational purposes, we try to detect LED events here and
 207 * print debug messages for it. */
 208static void handle_output(struct uhid_event *ev)
 209{
 210        /* LED messages are adverised via OUTPUT reports; ignore the rest */
 211        if (ev->u.output.rtype != UHID_OUTPUT_REPORT)
 212                return;
 213        /* LED reports have length 2 bytes */
 214        if (ev->u.output.size != 2)
 215                return;
 216        /* first byte is report-id which is 0x02 for LEDs in our rdesc */
 217        if (ev->u.output.data[0] != 0x2)
 218                return;
 219
 220        /* print flags payload */
 221        fprintf(stderr, "LED output report received with flags %x\n",
 222                ev->u.output.data[1]);
 223}
 224
 225static int event(int fd)
 226{
 227        struct uhid_event ev;
 228        ssize_t ret;
 229
 230        memset(&ev, 0, sizeof(ev));
 231        ret = read(fd, &ev, sizeof(ev));
 232        if (ret == 0) {
 233                fprintf(stderr, "Read HUP on uhid-cdev\n");
 234                return -EFAULT;
 235        } else if (ret < 0) {
 236                fprintf(stderr, "Cannot read uhid-cdev: %m\n");
 237                return -errno;
 238        } else if (ret != sizeof(ev)) {
 239                fprintf(stderr, "Invalid size read from uhid-dev: %ld != %lu\n",
 240                        ret, sizeof(ev));
 241                return -EFAULT;
 242        }
 243
 244        switch (ev.type) {
 245        case UHID_START:
 246                fprintf(stderr, "UHID_START from uhid-dev\n");
 247                break;
 248        case UHID_STOP:
 249                fprintf(stderr, "UHID_STOP from uhid-dev\n");
 250                break;
 251        case UHID_OPEN:
 252                fprintf(stderr, "UHID_OPEN from uhid-dev\n");
 253                break;
 254        case UHID_CLOSE:
 255                fprintf(stderr, "UHID_CLOSE from uhid-dev\n");
 256                break;
 257        case UHID_OUTPUT:
 258                fprintf(stderr, "UHID_OUTPUT from uhid-dev\n");
 259                handle_output(&ev);
 260                break;
 261        case UHID_OUTPUT_EV:
 262                fprintf(stderr, "UHID_OUTPUT_EV from uhid-dev\n");
 263                break;
 264        default:
 265                fprintf(stderr, "Invalid event from uhid-dev: %u\n", ev.type);
 266        }
 267
 268        return 0;
 269}
 270
 271static bool btn1_down;
 272static bool btn2_down;
 273static bool btn3_down;
 274static signed char abs_hor;
 275static signed char abs_ver;
 276static signed char wheel;
 277
 278static int send_event(int fd)
 279{
 280        struct uhid_event ev;
 281
 282        memset(&ev, 0, sizeof(ev));
 283        ev.type = UHID_INPUT;
 284        ev.u.input.size = 5;
 285
 286        ev.u.input.data[0] = 0x1;
 287        if (btn1_down)
 288                ev.u.input.data[1] |= 0x1;
 289        if (btn2_down)
 290                ev.u.input.data[1] |= 0x2;
 291        if (btn3_down)
 292                ev.u.input.data[1] |= 0x4;
 293
 294        ev.u.input.data[2] = abs_hor;
 295        ev.u.input.data[3] = abs_ver;
 296        ev.u.input.data[4] = wheel;
 297
 298        return uhid_write(fd, &ev);
 299}
 300
 301static int keyboard(int fd)
 302{
 303        char buf[128];
 304        ssize_t ret, i;
 305
 306        ret = read(STDIN_FILENO, buf, sizeof(buf));
 307        if (ret == 0) {
 308                fprintf(stderr, "Read HUP on stdin\n");
 309                return -EFAULT;
 310        } else if (ret < 0) {
 311                fprintf(stderr, "Cannot read stdin: %m\n");
 312                return -errno;
 313        }
 314
 315        for (i = 0; i < ret; ++i) {
 316                switch (buf[i]) {
 317                case '1':
 318                        btn1_down = !btn1_down;
 319                        ret = send_event(fd);
 320                        if (ret)
 321                                return ret;
 322                        break;
 323                case '2':
 324                        btn2_down = !btn2_down;
 325                        ret = send_event(fd);
 326                        if (ret)
 327                                return ret;
 328                        break;
 329                case '3':
 330                        btn3_down = !btn3_down;
 331                        ret = send_event(fd);
 332                        if (ret)
 333                                return ret;
 334                        break;
 335                case 'a':
 336                        abs_hor = -20;
 337                        ret = send_event(fd);
 338                        abs_hor = 0;
 339                        if (ret)
 340                                return ret;
 341                        break;
 342                case 'd':
 343                        abs_hor = 20;
 344                        ret = send_event(fd);
 345                        abs_hor = 0;
 346                        if (ret)
 347                                return ret;
 348                        break;
 349                case 'w':
 350                        abs_ver = -20;
 351                        ret = send_event(fd);
 352                        abs_ver = 0;
 353                        if (ret)
 354                                return ret;
 355                        break;
 356                case 's':
 357                        abs_ver = 20;
 358                        ret = send_event(fd);
 359                        abs_ver = 0;
 360                        if (ret)
 361                                return ret;
 362                        break;
 363                case 'r':
 364                        wheel = 1;
 365                        ret = send_event(fd);
 366                        wheel = 0;
 367                        if (ret)
 368                                return ret;
 369                        break;
 370                case 'f':
 371                        wheel = -1;
 372                        ret = send_event(fd);
 373                        wheel = 0;
 374                        if (ret)
 375                                return ret;
 376                        break;
 377                case 'q':
 378                        return -ECANCELED;
 379                default:
 380                        fprintf(stderr, "Invalid input: %c\n", buf[i]);
 381                }
 382        }
 383
 384        return 0;
 385}
 386
 387int main(int argc, char **argv)
 388{
 389        int fd;
 390        const char *path = "/dev/uhid";
 391        struct pollfd pfds[2];
 392        int ret;
 393        struct termios state;
 394
 395        ret = tcgetattr(STDIN_FILENO, &state);
 396        if (ret) {
 397                fprintf(stderr, "Cannot get tty state\n");
 398        } else {
 399                state.c_lflag &= ~ICANON;
 400                state.c_cc[VMIN] = 1;
 401                ret = tcsetattr(STDIN_FILENO, TCSANOW, &state);
 402                if (ret)
 403                        fprintf(stderr, "Cannot set tty state\n");
 404        }
 405
 406        if (argc >= 2) {
 407                if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
 408                        fprintf(stderr, "Usage: %s [%s]\n", argv[0], path);
 409                        return EXIT_SUCCESS;
 410                } else {
 411                        path = argv[1];
 412                }
 413        }
 414
 415        fprintf(stderr, "Open uhid-cdev %s\n", path);
 416        fd = open(path, O_RDWR | O_CLOEXEC);
 417        if (fd < 0) {
 418                fprintf(stderr, "Cannot open uhid-cdev %s: %m\n", path);
 419                return EXIT_FAILURE;
 420        }
 421
 422        fprintf(stderr, "Create uhid device\n");
 423        ret = create(fd);
 424        if (ret) {
 425                close(fd);
 426                return EXIT_FAILURE;
 427        }
 428
 429        pfds[0].fd = STDIN_FILENO;
 430        pfds[0].events = POLLIN;
 431        pfds[1].fd = fd;
 432        pfds[1].events = POLLIN;
 433
 434        fprintf(stderr, "Press 'q' to quit...\n");
 435        while (1) {
 436                ret = poll(pfds, 2, -1);
 437                if (ret < 0) {
 438                        fprintf(stderr, "Cannot poll for fds: %m\n");
 439                        break;
 440                }
 441                if (pfds[0].revents & POLLHUP) {
 442                        fprintf(stderr, "Received HUP on stdin\n");
 443                        break;
 444                }
 445                if (pfds[1].revents & POLLHUP) {
 446                        fprintf(stderr, "Received HUP on uhid-cdev\n");
 447                        break;
 448                }
 449
 450                if (pfds[0].revents & POLLIN) {
 451                        ret = keyboard(fd);
 452                        if (ret)
 453                                break;
 454                }
 455                if (pfds[1].revents & POLLIN) {
 456                        ret = event(fd);
 457                        if (ret)
 458                                break;
 459                }
 460        }
 461
 462        fprintf(stderr, "Destroy uhid device\n");
 463        destroy(fd);
 464        return EXIT_SUCCESS;
 465}
 466