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: %zd != %zu\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: %zd != %zu\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 }
466
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.