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}
178