Loading...
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/input.h>
32#include <errno.h>
33#include <stdio.h>
34#include <stdlib.h>
35#include <string.h>
36#include <unistd.h>
37#include <poll.h>
38#include <sys/types.h>
39#include <sys/ioctl.h>
40#include <sys/stat.h>
41#include <fcntl.h>
42
43#include "bpf_util.h"
44#include <bpf/bpf.h>
45#include <bpf/libbpf.h>
46
47#include "testing_helpers.h"
48
49int main(int argc, char **argv)
50{
51 struct bpf_object *obj;
52 int ret, lircfd, progfd, inputfd;
53 int testir1 = 0x1dead;
54 int testir2 = 0x20101;
55 u32 prog_ids[10], prog_flags[10], prog_cnt;
56
57 if (argc != 3) {
58 printf("Usage: %s /dev/lircN /dev/input/eventM\n", argv[0]);
59 return 2;
60 }
61
62 ret = bpf_prog_test_load("test_lirc_mode2_kern.bpf.o",
63 BPF_PROG_TYPE_LIRC_MODE2, &obj, &progfd);
64 if (ret) {
65 printf("Failed to load bpf program\n");
66 return 1;
67 }
68
69 lircfd = open(argv[1], O_RDWR | O_NONBLOCK);
70 if (lircfd == -1) {
71 printf("failed to open lirc device %s: %m\n", argv[1]);
72 return 1;
73 }
74
75 /* Let's try detach it before it was ever attached */
76 ret = bpf_prog_detach2(progfd, lircfd, BPF_LIRC_MODE2);
77 if (ret != -1 || errno != ENOENT) {
78 printf("bpf_prog_detach2 not attached should fail: %m\n");
79 return 1;
80 }
81
82 inputfd = open(argv[2], O_RDONLY | O_NONBLOCK);
83 if (inputfd == -1) {
84 printf("failed to open input device %s: %m\n", argv[1]);
85 return 1;
86 }
87
88 prog_cnt = 10;
89 ret = bpf_prog_query(lircfd, BPF_LIRC_MODE2, 0, prog_flags, prog_ids,
90 &prog_cnt);
91 if (ret) {
92 printf("Failed to query bpf programs on lirc device: %m\n");
93 return 1;
94 }
95
96 if (prog_cnt != 0) {
97 printf("Expected nothing to be attached\n");
98 return 1;
99 }
100
101 ret = bpf_prog_attach(progfd, lircfd, BPF_LIRC_MODE2, 0);
102 if (ret) {
103 printf("Failed to attach bpf to lirc device: %m\n");
104 return 1;
105 }
106
107 /* Write raw IR */
108 ret = write(lircfd, &testir1, sizeof(testir1));
109 if (ret != sizeof(testir1)) {
110 printf("Failed to send test IR message: %m\n");
111 return 1;
112 }
113
114 struct pollfd pfd = { .fd = inputfd, .events = POLLIN };
115 struct input_event event;
116
117 for (;;) {
118 poll(&pfd, 1, 100);
119
120 /* Read decoded IR */
121 ret = read(inputfd, &event, sizeof(event));
122 if (ret != sizeof(event)) {
123 printf("Failed to read decoded IR: %m\n");
124 return 1;
125 }
126
127 if (event.type == EV_MSC && event.code == MSC_SCAN &&
128 event.value == 0xdead) {
129 break;
130 }
131 }
132
133 /* Write raw IR */
134 ret = write(lircfd, &testir2, sizeof(testir2));
135 if (ret != sizeof(testir2)) {
136 printf("Failed to send test IR message: %m\n");
137 return 1;
138 }
139
140 for (;;) {
141 poll(&pfd, 1, 100);
142
143 /* Read decoded IR */
144 ret = read(inputfd, &event, sizeof(event));
145 if (ret != sizeof(event)) {
146 printf("Failed to read decoded IR: %m\n");
147 return 1;
148 }
149
150 if (event.type == EV_REL && event.code == REL_Y &&
151 event.value == 1 ) {
152 break;
153 }
154 }
155
156 prog_cnt = 10;
157 ret = bpf_prog_query(lircfd, BPF_LIRC_MODE2, 0, prog_flags, prog_ids,
158 &prog_cnt);
159 if (ret) {
160 printf("Failed to query bpf programs on lirc device: %m\n");
161 return 1;
162 }
163
164 if (prog_cnt != 1) {
165 printf("Expected one program to be attached\n");
166 return 1;
167 }
168
169 /* Let's try detaching it now it is actually attached */
170 ret = bpf_prog_detach2(progfd, lircfd, BPF_LIRC_MODE2);
171 if (ret) {
172 printf("bpf_prog_detach2: returned %m\n");
173 return 1;
174 }
175
176 return 0;
177}
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
48int 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}