samples/uhid/uhid-example.c

   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
 112 static 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
 159 static 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
 176 static 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
 194 static 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. */
 208 static 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
 225 static 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
 271 static bool btn1_down;
 272 static bool btn2_down;
 273 static bool btn3_down;
 274 static signed char abs_hor;
 275 static signed char abs_ver;
 276 static signed char wheel;
 277
 278 static 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
 301 static 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
 387 int 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 }