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