1 // SPDX-License-Identifier: GPL-2.0
2 // test ir decoder
3 //
4 // Copyright (C) 2018 Sean Young <sean@mess.org>
5 
6 // A lirc chardev is a device representing a consumer IR (cir) device which
7 // can receive infrared signals from remote control and/or transmit IR.
8 //
9 // IR is sent as a series of pulses and space somewhat like morse code. The
10 // BPF program can decode this into scancodes so that rc-core can translate
11 // this into input key codes using the rc keymap.
12 //
13 // This test works by sending IR over rc-loopback, so the IR is processed by
14 // BPF and then decoded into scancodes. The lirc chardev must be the one
15 // associated with rc-loopback, see the output of ir-keytable(1).
16 //
17 // The following CONFIG options must be enabled for the test to succeed:
18 // CONFIG_RC_CORE=y
19 // CONFIG_BPF_RAWIR_EVENT=y
20 // CONFIG_RC_LOOPBACK=y
21 
22 // Steps:
23 // 1. Open the /dev/lircN device for rc-loopback (given on command line)
24 // 2. Attach bpf_lirc_mode2 program which decodes some IR.
25 // 3. Send some IR to the same IR device; since it is loopback, this will
26 //    end up in the bpf program
27 // 4. bpf program should decode IR and report keycode
28 // 5. We can read keycode from same /dev/lirc device
29 
30 #include <linux/bpf.h>
31 #include <linux/lirc.h>
32 #include <linux/input.h>
33 #include <errno.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <unistd.h>
38 #include <poll.h>
39 #include <sys/types.h>
40 #include <sys/ioctl.h>
41 #include <sys/stat.h>
42 #include <fcntl.h>
43 
44 #include "bpf_util.h"
45 #include <bpf/bpf.h>
46 #include <bpf/libbpf.h>
47 
main(int argc,char ** argv)48 int main(int argc, char **argv)
49 {
50 	struct bpf_object *obj;
51 	int ret, lircfd, progfd, inputfd;
52 	int testir1 = 0x1dead;
53 	int testir2 = 0x20101;
54 	u32 prog_ids[10], prog_flags[10], prog_cnt;
55 
56 	if (argc != 3) {
57 		printf("Usage: %s /dev/lircN /dev/input/eventM\n", argv[0]);
58 		return 2;
59 	}
60 
61 	ret = bpf_prog_load("test_lirc_mode2_kern.o",
62 			    BPF_PROG_TYPE_LIRC_MODE2, &obj, &progfd);
63 	if (ret) {
64 		printf("Failed to load bpf program\n");
65 		return 1;
66 	}
67 
68 	lircfd = open(argv[1], O_RDWR | O_NONBLOCK);
69 	if (lircfd == -1) {
70 		printf("failed to open lirc device %s: %m\n", argv[1]);
71 		return 1;
72 	}
73 
74 	/* Let's try detach it before it was ever attached */
75 	ret = bpf_prog_detach2(progfd, lircfd, BPF_LIRC_MODE2);
76 	if (ret != -1 || errno != ENOENT) {
77 		printf("bpf_prog_detach2 not attached should fail: %m\n");
78 		return 1;
79 	}
80 
81 	inputfd = open(argv[2], O_RDONLY | O_NONBLOCK);
82 	if (inputfd == -1) {
83 		printf("failed to open input device %s: %m\n", argv[1]);
84 		return 1;
85 	}
86 
87 	prog_cnt = 10;
88 	ret = bpf_prog_query(lircfd, BPF_LIRC_MODE2, 0, prog_flags, prog_ids,
89 			     &prog_cnt);
90 	if (ret) {
91 		printf("Failed to query bpf programs on lirc device: %m\n");
92 		return 1;
93 	}
94 
95 	if (prog_cnt != 0) {
96 		printf("Expected nothing to be attached\n");
97 		return 1;
98 	}
99 
100 	ret = bpf_prog_attach(progfd, lircfd, BPF_LIRC_MODE2, 0);
101 	if (ret) {
102 		printf("Failed to attach bpf to lirc device: %m\n");
103 		return 1;
104 	}
105 
106 	/* Write raw IR */
107 	ret = write(lircfd, &testir1, sizeof(testir1));
108 	if (ret != sizeof(testir1)) {
109 		printf("Failed to send test IR message: %m\n");
110 		return 1;
111 	}
112 
113 	struct pollfd pfd = { .fd = inputfd, .events = POLLIN };
114 	struct input_event event;
115 
116 	for (;;) {
117 		poll(&pfd, 1, 100);
118 
119 		/* Read decoded IR */
120 		ret = read(inputfd, &event, sizeof(event));
121 		if (ret != sizeof(event)) {
122 			printf("Failed to read decoded IR: %m\n");
123 			return 1;
124 		}
125 
126 		if (event.type == EV_MSC && event.code == MSC_SCAN &&
127 		    event.value == 0xdead) {
128 			break;
129 		}
130 	}
131 
132 	/* Write raw IR */
133 	ret = write(lircfd, &testir2, sizeof(testir2));
134 	if (ret != sizeof(testir2)) {
135 		printf("Failed to send test IR message: %m\n");
136 		return 1;
137 	}
138 
139 	for (;;) {
140 		poll(&pfd, 1, 100);
141 
142 		/* Read decoded IR */
143 		ret = read(inputfd, &event, sizeof(event));
144 		if (ret != sizeof(event)) {
145 			printf("Failed to read decoded IR: %m\n");
146 			return 1;
147 		}
148 
149 		if (event.type == EV_REL && event.code == REL_Y &&
150 		    event.value == 1 ) {
151 			break;
152 		}
153 	}
154 
155 	prog_cnt = 10;
156 	ret = bpf_prog_query(lircfd, BPF_LIRC_MODE2, 0, prog_flags, prog_ids,
157 			     &prog_cnt);
158 	if (ret) {
159 		printf("Failed to query bpf programs on lirc device: %m\n");
160 		return 1;
161 	}
162 
163 	if (prog_cnt != 1) {
164 		printf("Expected one program to be attached\n");
165 		return 1;
166 	}
167 
168 	/* Let's try detaching it now it is actually attached */
169 	ret = bpf_prog_detach2(progfd, lircfd, BPF_LIRC_MODE2);
170 	if (ret) {
171 		printf("bpf_prog_detach2: returned %m\n");
172 		return 1;
173 	}
174 
175 	return 0;
176 }
177