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}