Merge branch 'bpf-ir-decoder'
Sean Young says: ==================== The kernel IR decoders (drivers/media/rc/ir-*-decoder.c) support the most widely used IR protocols, but there are many protocols which are not supported[1]. For example, the lirc-remotes[2] repo has over 2700 remotes, many of which are not supported by rc-core. There is a "long tail" of unsupported IR protocols, for which lircd is need to decode the IR . IR encoding is done in such a way that some simple circuit can decode it; therefore, bpf is ideal. In order to support all these protocols, here we have bpf based IR decoding. The idea is that user-space can define a decoder in bpf, attach it to the rc device through the lirc chardev. Separate work is underway to extend ir-keytable to have an extensive library of bpf-based decoders, and a much expanded library of rc keymaps. Another future application would be to compile IRP[3] to a IR BPF program, and so support virtually every remote without having to write a decoder for each. It might also be possible to support non-button devices such as analog directional pads or air conditioning remote controls and decode the target temperature in bpf, and pass that to an input device. [1] http://www.hifi-remote.com/wiki/index.php?title=DecodeIR [2] https://sourceforge.net/p/lirc-remotes/code/ci/master/tree/remotes/ [3] http://www.hifi-remote.com/wiki/index.php?title=IRP_Notation Changes since v4: - Renamed rc_dev_bpf_{attach,detach,query} to lirc_bpf_{attach,detach,query} - Fixed error path in lirc_bpf_query - Rebased on bpf-next Changes since v3: - Implemented review comments from Quentin Monnet and Y Song (thanks!) - More helpful and better formatted bpf helper documentation - Changed back to bpf_prog_array rather than open-coded implementation - scancodes can be 64 bit - bpf gets passed values in microseconds, not nanoseconds. microseconds is more than than enough (IR receivers support carriers upto 70kHz, at which point a single period is already 14 microseconds). Also, this makes it much more consistent with lirc mode2. - Since it looks much more like lirc mode2, rename the program type to BPF_PROG_TYPE_LIRC_MODE2. - Rebased on bpf-next Changes since v2: - Fixed locking issues - Improved self-test to cover more cases - Rebased on bpf-next again Changes since v1: - Code review comments from Y Song <ys114321@gmail.com> and Randy Dunlap <rdunlap@infradead.org> - Re-wrote sample bpf to be selftest - Renamed RAWIR_DECODER -> RAWIR_EVENT (Kconfig, context, bpf prog type) - Rebase on bpf-next - Introduced bpf_rawir_event context structure with simpler access checking ==================== Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
This commit is contained in:
Daniel Borkmann
commit
ee7dbd9747
|
|
@ -25,6 +25,19 @@ config LIRC
|
|||
passes raw IR to and from userspace, which is needed for
|
||||
IR transmitting (aka "blasting") and for the lirc daemon.
|
||||
|
||||
config BPF_LIRC_MODE2
|
||||
bool "Support for eBPF programs attached to lirc devices"
|
||||
depends on BPF_SYSCALL
|
||||
depends on RC_CORE=y
|
||||
depends on LIRC
|
||||
help
|
||||
Allow attaching eBPF programs to a lirc device using the bpf(2)
|
||||
syscall command BPF_PROG_ATTACH. This is supported for raw IR
|
||||
receivers.
|
||||
|
||||
These eBPF programs can be used to decode IR into scancodes, for
|
||||
IR protocols not supported by the kernel decoders.
|
||||
|
||||
menuconfig RC_DECODERS
|
||||
bool "Remote controller decoders"
|
||||
depends on RC_CORE
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ obj-y += keymaps/
|
|||
obj-$(CONFIG_RC_CORE) += rc-core.o
|
||||
rc-core-y := rc-main.o rc-ir-raw.o
|
||||
rc-core-$(CONFIG_LIRC) += lirc_dev.o
|
||||
rc-core-$(CONFIG_BPF_LIRC_MODE2) += bpf-lirc.o
|
||||
obj-$(CONFIG_IR_NEC_DECODER) += ir-nec-decoder.o
|
||||
obj-$(CONFIG_IR_RC5_DECODER) += ir-rc5-decoder.o
|
||||
obj-$(CONFIG_IR_RC6_DECODER) += ir-rc6-decoder.o
|
||||
|
|
|
|||
|
|
@ -0,0 +1,313 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
// bpf-lirc.c - handles bpf
|
||||
//
|
||||
// Copyright (C) 2018 Sean Young <sean@mess.org>
|
||||
|
||||
#include <linux/bpf.h>
|
||||
#include <linux/filter.h>
|
||||
#include <linux/bpf_lirc.h>
|
||||
#include "rc-core-priv.h"
|
||||
|
||||
/*
|
||||
* BPF interface for raw IR
|
||||
*/
|
||||
const struct bpf_prog_ops lirc_mode2_prog_ops = {
|
||||
};
|
||||
|
||||
BPF_CALL_1(bpf_rc_repeat, u32*, sample)
|
||||
{
|
||||
struct ir_raw_event_ctrl *ctrl;
|
||||
|
||||
ctrl = container_of(sample, struct ir_raw_event_ctrl, bpf_sample);
|
||||
|
||||
rc_repeat(ctrl->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct bpf_func_proto rc_repeat_proto = {
|
||||
.func = bpf_rc_repeat,
|
||||
.gpl_only = true, /* rc_repeat is EXPORT_SYMBOL_GPL */
|
||||
.ret_type = RET_INTEGER,
|
||||
.arg1_type = ARG_PTR_TO_CTX,
|
||||
};
|
||||
|
||||
/*
|
||||
* Currently rc-core does not support 64-bit scancodes, but there are many
|
||||
* known protocols with more than 32 bits. So, define the interface as u64
|
||||
* as a future-proof.
|
||||
*/
|
||||
BPF_CALL_4(bpf_rc_keydown, u32*, sample, u32, protocol, u64, scancode,
|
||||
u32, toggle)
|
||||
{
|
||||
struct ir_raw_event_ctrl *ctrl;
|
||||
|
||||
ctrl = container_of(sample, struct ir_raw_event_ctrl, bpf_sample);
|
||||
|
||||
rc_keydown(ctrl->dev, protocol, scancode, toggle != 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct bpf_func_proto rc_keydown_proto = {
|
||||
.func = bpf_rc_keydown,
|
||||
.gpl_only = true, /* rc_keydown is EXPORT_SYMBOL_GPL */
|
||||
.ret_type = RET_INTEGER,
|
||||
.arg1_type = ARG_PTR_TO_CTX,
|
||||
.arg2_type = ARG_ANYTHING,
|
||||
.arg3_type = ARG_ANYTHING,
|
||||
.arg4_type = ARG_ANYTHING,
|
||||
};
|
||||
|
||||
static const struct bpf_func_proto *
|
||||
lirc_mode2_func_proto(enum bpf_func_id func_id, const struct bpf_prog *prog)
|
||||
{
|
||||
switch (func_id) {
|
||||
case BPF_FUNC_rc_repeat:
|
||||
return &rc_repeat_proto;
|
||||
case BPF_FUNC_rc_keydown:
|
||||
return &rc_keydown_proto;
|
||||
case BPF_FUNC_map_lookup_elem:
|
||||
return &bpf_map_lookup_elem_proto;
|
||||
case BPF_FUNC_map_update_elem:
|
||||
return &bpf_map_update_elem_proto;
|
||||
case BPF_FUNC_map_delete_elem:
|
||||
return &bpf_map_delete_elem_proto;
|
||||
case BPF_FUNC_ktime_get_ns:
|
||||
return &bpf_ktime_get_ns_proto;
|
||||
case BPF_FUNC_tail_call:
|
||||
return &bpf_tail_call_proto;
|
||||
case BPF_FUNC_get_prandom_u32:
|
||||
return &bpf_get_prandom_u32_proto;
|
||||
case BPF_FUNC_trace_printk:
|
||||
if (capable(CAP_SYS_ADMIN))
|
||||
return bpf_get_trace_printk_proto();
|
||||
/* fall through */
|
||||
default:
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
static bool lirc_mode2_is_valid_access(int off, int size,
|
||||
enum bpf_access_type type,
|
||||
const struct bpf_prog *prog,
|
||||
struct bpf_insn_access_aux *info)
|
||||
{
|
||||
/* We have one field of u32 */
|
||||
return type == BPF_READ && off == 0 && size == sizeof(u32);
|
||||
}
|
||||
|
||||
const struct bpf_verifier_ops lirc_mode2_verifier_ops = {
|
||||
.get_func_proto = lirc_mode2_func_proto,
|
||||
.is_valid_access = lirc_mode2_is_valid_access
|
||||
};
|
||||
|
||||
#define BPF_MAX_PROGS 64
|
||||
|
||||
static int lirc_bpf_attach(struct rc_dev *rcdev, struct bpf_prog *prog)
|
||||
{
|
||||
struct bpf_prog_array __rcu *old_array;
|
||||
struct bpf_prog_array *new_array;
|
||||
struct ir_raw_event_ctrl *raw;
|
||||
int ret;
|
||||
|
||||
if (rcdev->driver_type != RC_DRIVER_IR_RAW)
|
||||
return -EINVAL;
|
||||
|
||||
ret = mutex_lock_interruptible(&ir_raw_handler_lock);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
raw = rcdev->raw;
|
||||
if (!raw) {
|
||||
ret = -ENODEV;
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
if (raw->progs && bpf_prog_array_length(raw->progs) >= BPF_MAX_PROGS) {
|
||||
ret = -E2BIG;
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
old_array = raw->progs;
|
||||
ret = bpf_prog_array_copy(old_array, NULL, prog, &new_array);
|
||||
if (ret < 0)
|
||||
goto unlock;
|
||||
|
||||
rcu_assign_pointer(raw->progs, new_array);
|
||||
bpf_prog_array_free(old_array);
|
||||
|
||||
unlock:
|
||||
mutex_unlock(&ir_raw_handler_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int lirc_bpf_detach(struct rc_dev *rcdev, struct bpf_prog *prog)
|
||||
{
|
||||
struct bpf_prog_array __rcu *old_array;
|
||||
struct bpf_prog_array *new_array;
|
||||
struct ir_raw_event_ctrl *raw;
|
||||
int ret;
|
||||
|
||||
if (rcdev->driver_type != RC_DRIVER_IR_RAW)
|
||||
return -EINVAL;
|
||||
|
||||
ret = mutex_lock_interruptible(&ir_raw_handler_lock);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
raw = rcdev->raw;
|
||||
if (!raw) {
|
||||
ret = -ENODEV;
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
old_array = raw->progs;
|
||||
ret = bpf_prog_array_copy(old_array, prog, NULL, &new_array);
|
||||
/*
|
||||
* Do not use bpf_prog_array_delete_safe() as we would end up
|
||||
* with a dummy entry in the array, and the we would free the
|
||||
* dummy in lirc_bpf_free()
|
||||
*/
|
||||
if (ret)
|
||||
goto unlock;
|
||||
|
||||
rcu_assign_pointer(raw->progs, new_array);
|
||||
bpf_prog_array_free(old_array);
|
||||
unlock:
|
||||
mutex_unlock(&ir_raw_handler_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void lirc_bpf_run(struct rc_dev *rcdev, u32 sample)
|
||||
{
|
||||
struct ir_raw_event_ctrl *raw = rcdev->raw;
|
||||
|
||||
raw->bpf_sample = sample;
|
||||
|
||||
if (raw->progs)
|
||||
BPF_PROG_RUN_ARRAY(raw->progs, &raw->bpf_sample, BPF_PROG_RUN);
|
||||
}
|
||||
|
||||
/*
|
||||
* This should be called once the rc thread has been stopped, so there can be
|
||||
* no concurrent bpf execution.
|
||||
*/
|
||||
void lirc_bpf_free(struct rc_dev *rcdev)
|
||||
{
|
||||
struct bpf_prog **progs;
|
||||
|
||||
if (!rcdev->raw->progs)
|
||||
return;
|
||||
|
||||
progs = rcu_dereference(rcdev->raw->progs)->progs;
|
||||
while (*progs)
|
||||
bpf_prog_put(*progs++);
|
||||
|
||||
bpf_prog_array_free(rcdev->raw->progs);
|
||||
}
|
||||
|
||||
int lirc_prog_attach(const union bpf_attr *attr)
|
||||
{
|
||||
struct bpf_prog *prog;
|
||||
struct rc_dev *rcdev;
|
||||
int ret;
|
||||
|
||||
if (attr->attach_flags)
|
||||
return -EINVAL;
|
||||
|
||||
prog = bpf_prog_get_type(attr->attach_bpf_fd,
|
||||
BPF_PROG_TYPE_LIRC_MODE2);
|
||||
if (IS_ERR(prog))
|
||||
return PTR_ERR(prog);
|
||||
|
||||
rcdev = rc_dev_get_from_fd(attr->target_fd);
|
||||
if (IS_ERR(rcdev)) {
|
||||
bpf_prog_put(prog);
|
||||
return PTR_ERR(rcdev);
|
||||
}
|
||||
|
||||
ret = lirc_bpf_attach(rcdev, prog);
|
||||
if (ret)
|
||||
bpf_prog_put(prog);
|
||||
|
||||
put_device(&rcdev->dev);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lirc_prog_detach(const union bpf_attr *attr)
|
||||
{
|
||||
struct bpf_prog *prog;
|
||||
struct rc_dev *rcdev;
|
||||
int ret;
|
||||
|
||||
if (attr->attach_flags)
|
||||
return -EINVAL;
|
||||
|
||||
prog = bpf_prog_get_type(attr->attach_bpf_fd,
|
||||
BPF_PROG_TYPE_LIRC_MODE2);
|
||||
if (IS_ERR(prog))
|
||||
return PTR_ERR(prog);
|
||||
|
||||
rcdev = rc_dev_get_from_fd(attr->target_fd);
|
||||
if (IS_ERR(rcdev)) {
|
||||
bpf_prog_put(prog);
|
||||
return PTR_ERR(rcdev);
|
||||
}
|
||||
|
||||
ret = lirc_bpf_detach(rcdev, prog);
|
||||
|
||||
bpf_prog_put(prog);
|
||||
put_device(&rcdev->dev);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int lirc_prog_query(const union bpf_attr *attr, union bpf_attr __user *uattr)
|
||||
{
|
||||
__u32 __user *prog_ids = u64_to_user_ptr(attr->query.prog_ids);
|
||||
struct bpf_prog_array __rcu *progs;
|
||||
struct rc_dev *rcdev;
|
||||
u32 cnt, flags = 0;
|
||||
int ret;
|
||||
|
||||
if (attr->query.query_flags)
|
||||
return -EINVAL;
|
||||
|
||||
rcdev = rc_dev_get_from_fd(attr->query.target_fd);
|
||||
if (IS_ERR(rcdev))
|
||||
return PTR_ERR(rcdev);
|
||||
|
||||
if (rcdev->driver_type != RC_DRIVER_IR_RAW) {
|
||||
ret = -EINVAL;
|
||||
goto put;
|
||||
}
|
||||
|
||||
ret = mutex_lock_interruptible(&ir_raw_handler_lock);
|
||||
if (ret)
|
||||
goto put;
|
||||
|
||||
progs = rcdev->raw->progs;
|
||||
cnt = progs ? bpf_prog_array_length(progs) : 0;
|
||||
|
||||
if (copy_to_user(&uattr->query.prog_cnt, &cnt, sizeof(cnt))) {
|
||||
ret = -EFAULT;
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
if (copy_to_user(&uattr->query.attach_flags, &flags, sizeof(flags))) {
|
||||
ret = -EFAULT;
|
||||
goto unlock;
|
||||
}
|
||||
|
||||
if (attr->query.prog_cnt != 0 && prog_ids && cnt)
|
||||
ret = bpf_prog_array_copy_to_user(progs, prog_ids, cnt);
|
||||
|
||||
unlock:
|
||||
mutex_unlock(&ir_raw_handler_lock);
|
||||
put:
|
||||
put_device(&rcdev->dev);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
|
@ -20,6 +20,7 @@
|
|||
#include <linux/module.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/file.h>
|
||||
#include <linux/idr.h>
|
||||
#include <linux/poll.h>
|
||||
#include <linux/sched.h>
|
||||
|
|
@ -104,6 +105,12 @@ void ir_lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev)
|
|||
TO_US(ev.duration), TO_STR(ev.pulse));
|
||||
}
|
||||
|
||||
/*
|
||||
* bpf does not care about the gap generated above; that exists
|
||||
* for backwards compatibility
|
||||
*/
|
||||
lirc_bpf_run(dev, sample);
|
||||
|
||||
spin_lock_irqsave(&dev->lirc_fh_lock, flags);
|
||||
list_for_each_entry(fh, &dev->lirc_fh, list) {
|
||||
if (LIRC_IS_TIMEOUT(sample) && !fh->send_timeout_reports)
|
||||
|
|
@ -816,4 +823,27 @@ void __exit lirc_dev_exit(void)
|
|||
unregister_chrdev_region(lirc_base_dev, RC_DEV_MAX);
|
||||
}
|
||||
|
||||
struct rc_dev *rc_dev_get_from_fd(int fd)
|
||||
{
|
||||
struct fd f = fdget(fd);
|
||||
struct lirc_fh *fh;
|
||||
struct rc_dev *dev;
|
||||
|
||||
if (!f.file)
|
||||
return ERR_PTR(-EBADF);
|
||||
|
||||
if (f.file->f_op != &lirc_fops) {
|
||||
fdput(f);
|
||||
return ERR_PTR(-EINVAL);
|
||||
}
|
||||
|
||||
fh = f.file->private_data;
|
||||
dev = fh->rc;
|
||||
|
||||
get_device(&dev->dev);
|
||||
fdput(f);
|
||||
|
||||
return dev;
|
||||
}
|
||||
|
||||
MODULE_ALIAS("lirc_dev");
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@
|
|||
#define MAX_IR_EVENT_SIZE 512
|
||||
|
||||
#include <linux/slab.h>
|
||||
#include <uapi/linux/bpf.h>
|
||||
#include <media/rc-core.h>
|
||||
|
||||
/**
|
||||
|
|
@ -57,6 +58,11 @@ struct ir_raw_event_ctrl {
|
|||
/* raw decoder state follows */
|
||||
struct ir_raw_event prev_ev;
|
||||
struct ir_raw_event this_ev;
|
||||
|
||||
#ifdef CONFIG_BPF_LIRC_MODE2
|
||||
u32 bpf_sample;
|
||||
struct bpf_prog_array __rcu *progs;
|
||||
#endif
|
||||
struct nec_dec {
|
||||
int state;
|
||||
unsigned count;
|
||||
|
|
@ -126,6 +132,9 @@ struct ir_raw_event_ctrl {
|
|||
} imon;
|
||||
};
|
||||
|
||||
/* Mutex for locking raw IR processing and handler change */
|
||||
extern struct mutex ir_raw_handler_lock;
|
||||
|
||||
/* macros for IR decoders */
|
||||
static inline bool geq_margin(unsigned d1, unsigned d2, unsigned margin)
|
||||
{
|
||||
|
|
@ -288,6 +297,7 @@ void ir_lirc_raw_event(struct rc_dev *dev, struct ir_raw_event ev);
|
|||
void ir_lirc_scancode_event(struct rc_dev *dev, struct lirc_scancode *lsc);
|
||||
int ir_lirc_register(struct rc_dev *dev);
|
||||
void ir_lirc_unregister(struct rc_dev *dev);
|
||||
struct rc_dev *rc_dev_get_from_fd(int fd);
|
||||
#else
|
||||
static inline int lirc_dev_init(void) { return 0; }
|
||||
static inline void lirc_dev_exit(void) {}
|
||||
|
|
@ -299,4 +309,15 @@ static inline int ir_lirc_register(struct rc_dev *dev) { return 0; }
|
|||
static inline void ir_lirc_unregister(struct rc_dev *dev) { }
|
||||
#endif
|
||||
|
||||
/*
|
||||
* bpf interface
|
||||
*/
|
||||
#ifdef CONFIG_BPF_LIRC_MODE2
|
||||
void lirc_bpf_free(struct rc_dev *dev);
|
||||
void lirc_bpf_run(struct rc_dev *dev, u32 sample);
|
||||
#else
|
||||
static inline void lirc_bpf_free(struct rc_dev *dev) { }
|
||||
static inline void lirc_bpf_run(struct rc_dev *dev, u32 sample) { }
|
||||
#endif
|
||||
|
||||
#endif /* _RC_CORE_PRIV */
|
||||
|
|
|
|||
|
|
@ -14,7 +14,7 @@
|
|||
static LIST_HEAD(ir_raw_client_list);
|
||||
|
||||
/* Used to handle IR raw handler extensions */
|
||||
static DEFINE_MUTEX(ir_raw_handler_lock);
|
||||
DEFINE_MUTEX(ir_raw_handler_lock);
|
||||
static LIST_HEAD(ir_raw_handler_list);
|
||||
static atomic64_t available_protocols = ATOMIC64_INIT(0);
|
||||
|
||||
|
|
@ -621,9 +621,17 @@ void ir_raw_event_unregister(struct rc_dev *dev)
|
|||
list_for_each_entry(handler, &ir_raw_handler_list, list)
|
||||
if (handler->raw_unregister)
|
||||
handler->raw_unregister(dev);
|
||||
mutex_unlock(&ir_raw_handler_lock);
|
||||
|
||||
lirc_bpf_free(dev);
|
||||
|
||||
ir_raw_event_free(dev);
|
||||
|
||||
/*
|
||||
* A user can be calling bpf(BPF_PROG_{QUERY|ATTACH|DETACH}), so
|
||||
* ensure that the raw member is null on unlock; this is how
|
||||
* "device gone" is checked.
|
||||
*/
|
||||
mutex_unlock(&ir_raw_handler_lock);
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -0,0 +1,29 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
#ifndef _BPF_LIRC_H
|
||||
#define _BPF_LIRC_H
|
||||
|
||||
#include <uapi/linux/bpf.h>
|
||||
|
||||
#ifdef CONFIG_BPF_LIRC_MODE2
|
||||
int lirc_prog_attach(const union bpf_attr *attr);
|
||||
int lirc_prog_detach(const union bpf_attr *attr);
|
||||
int lirc_prog_query(const union bpf_attr *attr, union bpf_attr __user *uattr);
|
||||
#else
|
||||
static inline int lirc_prog_attach(const union bpf_attr *attr)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static inline int lirc_prog_detach(const union bpf_attr *attr)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static inline int lirc_prog_query(const union bpf_attr *attr,
|
||||
union bpf_attr __user *uattr)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _BPF_LIRC_H */
|
||||
|
|
@ -26,6 +26,9 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_RAW_TRACEPOINT, raw_tracepoint)
|
|||
#ifdef CONFIG_CGROUP_BPF
|
||||
BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_DEVICE, cg_dev)
|
||||
#endif
|
||||
#ifdef CONFIG_BPF_LIRC_MODE2
|
||||
BPF_PROG_TYPE(BPF_PROG_TYPE_LIRC_MODE2, lirc_mode2)
|
||||
#endif
|
||||
|
||||
BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY, array_map_ops)
|
||||
BPF_MAP_TYPE(BPF_MAP_TYPE_PERCPU_ARRAY, percpu_array_map_ops)
|
||||
|
|
|
|||
|
|
@ -143,6 +143,7 @@ enum bpf_prog_type {
|
|||
BPF_PROG_TYPE_RAW_TRACEPOINT,
|
||||
BPF_PROG_TYPE_CGROUP_SOCK_ADDR,
|
||||
BPF_PROG_TYPE_LWT_SEG6LOCAL,
|
||||
BPF_PROG_TYPE_LIRC_MODE2,
|
||||
};
|
||||
|
||||
enum bpf_attach_type {
|
||||
|
|
@ -162,6 +163,7 @@ enum bpf_attach_type {
|
|||
BPF_CGROUP_INET6_POST_BIND,
|
||||
BPF_CGROUP_UDP4_SENDMSG,
|
||||
BPF_CGROUP_UDP6_SENDMSG,
|
||||
BPF_LIRC_MODE2,
|
||||
__MAX_BPF_ATTACH_TYPE
|
||||
};
|
||||
|
||||
|
|
@ -2005,6 +2007,53 @@ union bpf_attr {
|
|||
* direct packet access.
|
||||
* Return
|
||||
* 0 on success, or a negative error in case of failure.
|
||||
*
|
||||
* int bpf_rc_keydown(void *ctx, u32 protocol, u64 scancode, u32 toggle)
|
||||
* Description
|
||||
* This helper is used in programs implementing IR decoding, to
|
||||
* report a successfully decoded key press with *scancode*,
|
||||
* *toggle* value in the given *protocol*. The scancode will be
|
||||
* translated to a keycode using the rc keymap, and reported as
|
||||
* an input key down event. After a period a key up event is
|
||||
* generated. This period can be extended by calling either
|
||||
* **bpf_rc_keydown** () again with the same values, or calling
|
||||
* **bpf_rc_repeat** ().
|
||||
*
|
||||
* Some protocols include a toggle bit, in case the button was
|
||||
* released and pressed again between consecutive scancodes.
|
||||
*
|
||||
* The *ctx* should point to the lirc sample as passed into
|
||||
* the program.
|
||||
*
|
||||
* The *protocol* is the decoded protocol number (see
|
||||
* **enum rc_proto** for some predefined values).
|
||||
*
|
||||
* This helper is only available is the kernel was compiled with
|
||||
* the **CONFIG_BPF_LIRC_MODE2** configuration option set to
|
||||
* "**y**".
|
||||
*
|
||||
* Return
|
||||
* 0
|
||||
*
|
||||
* int bpf_rc_repeat(void *ctx)
|
||||
* Description
|
||||
* This helper is used in programs implementing IR decoding, to
|
||||
* report a successfully decoded repeat key message. This delays
|
||||
* the generation of a key up event for previously generated
|
||||
* key down event.
|
||||
*
|
||||
* Some IR protocols like NEC have a special IR message for
|
||||
* repeating last button, for when a button is held down.
|
||||
*
|
||||
* The *ctx* should point to the lirc sample as passed into
|
||||
* the program.
|
||||
*
|
||||
* This helper is only available is the kernel was compiled with
|
||||
* the **CONFIG_BPF_LIRC_MODE2** configuration option set to
|
||||
* "**y**".
|
||||
*
|
||||
* Return
|
||||
* 0
|
||||
*/
|
||||
#define __BPF_FUNC_MAPPER(FN) \
|
||||
FN(unspec), \
|
||||
|
|
@ -2083,7 +2132,9 @@ union bpf_attr {
|
|||
FN(lwt_push_encap), \
|
||||
FN(lwt_seg6_store_bytes), \
|
||||
FN(lwt_seg6_adjust_srh), \
|
||||
FN(lwt_seg6_action),
|
||||
FN(lwt_seg6_action), \
|
||||
FN(rc_repeat), \
|
||||
FN(rc_keydown),
|
||||
|
||||
/* integer value in 'imm' field of BPF_CALL instruction selects which helper
|
||||
* function eBPF program intends to call
|
||||
|
|
|
|||
|
|
@ -1616,6 +1616,7 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array,
|
|||
int new_prog_cnt, carry_prog_cnt = 0;
|
||||
struct bpf_prog **existing_prog;
|
||||
struct bpf_prog_array *array;
|
||||
bool found_exclude = false;
|
||||
int new_prog_idx = 0;
|
||||
|
||||
/* Figure out how many existing progs we need to carry over to
|
||||
|
|
@ -1624,14 +1625,20 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array,
|
|||
if (old_array) {
|
||||
existing_prog = old_array->progs;
|
||||
for (; *existing_prog; existing_prog++) {
|
||||
if (*existing_prog != exclude_prog &&
|
||||
*existing_prog != &dummy_bpf_prog.prog)
|
||||
if (*existing_prog == exclude_prog) {
|
||||
found_exclude = true;
|
||||
continue;
|
||||
}
|
||||
if (*existing_prog != &dummy_bpf_prog.prog)
|
||||
carry_prog_cnt++;
|
||||
if (*existing_prog == include_prog)
|
||||
return -EEXIST;
|
||||
}
|
||||
}
|
||||
|
||||
if (exclude_prog && !found_exclude)
|
||||
return -ENOENT;
|
||||
|
||||
/* How many progs (not NULL) will be in the new array? */
|
||||
new_prog_cnt = carry_prog_cnt;
|
||||
if (include_prog)
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@
|
|||
*/
|
||||
#include <linux/bpf.h>
|
||||
#include <linux/bpf_trace.h>
|
||||
#include <linux/bpf_lirc.h>
|
||||
#include <linux/btf.h>
|
||||
#include <linux/syscalls.h>
|
||||
#include <linux/slab.h>
|
||||
|
|
@ -1582,6 +1583,8 @@ static int bpf_prog_attach(const union bpf_attr *attr)
|
|||
case BPF_SK_SKB_STREAM_PARSER:
|
||||
case BPF_SK_SKB_STREAM_VERDICT:
|
||||
return sockmap_get_from_fd(attr, BPF_PROG_TYPE_SK_SKB, true);
|
||||
case BPF_LIRC_MODE2:
|
||||
return lirc_prog_attach(attr);
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
|
@ -1654,6 +1657,8 @@ static int bpf_prog_detach(const union bpf_attr *attr)
|
|||
case BPF_SK_SKB_STREAM_PARSER:
|
||||
case BPF_SK_SKB_STREAM_VERDICT:
|
||||
return sockmap_get_from_fd(attr, BPF_PROG_TYPE_SK_SKB, false);
|
||||
case BPF_LIRC_MODE2:
|
||||
return lirc_prog_detach(attr);
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
|
@ -1703,6 +1708,8 @@ static int bpf_prog_query(const union bpf_attr *attr,
|
|||
case BPF_CGROUP_SOCK_OPS:
|
||||
case BPF_CGROUP_DEVICE:
|
||||
break;
|
||||
case BPF_LIRC_MODE2:
|
||||
return lirc_prog_query(attr, uattr);
|
||||
default:
|
||||
return -EINVAL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1006,6 +1006,8 @@ void perf_event_detach_bpf_prog(struct perf_event *event)
|
|||
|
||||
old_array = event->tp_event->prog_array;
|
||||
ret = bpf_prog_array_copy(old_array, event->prog, NULL, &new_array);
|
||||
if (ret == -ENOENT)
|
||||
goto unlock;
|
||||
if (ret < 0) {
|
||||
bpf_prog_array_delete_safe(old_array, event->prog);
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -71,6 +71,7 @@ static const char * const prog_type_name[] = {
|
|||
[BPF_PROG_TYPE_SK_MSG] = "sk_msg",
|
||||
[BPF_PROG_TYPE_RAW_TRACEPOINT] = "raw_tracepoint",
|
||||
[BPF_PROG_TYPE_CGROUP_SOCK_ADDR] = "cgroup_sock_addr",
|
||||
[BPF_PROG_TYPE_LIRC_MODE2] = "lirc_mode2",
|
||||
};
|
||||
|
||||
static void print_boot_time(__u64 nsecs, char *buf, unsigned int size)
|
||||
|
|
|
|||
|
|
@ -143,6 +143,7 @@ enum bpf_prog_type {
|
|||
BPF_PROG_TYPE_RAW_TRACEPOINT,
|
||||
BPF_PROG_TYPE_CGROUP_SOCK_ADDR,
|
||||
BPF_PROG_TYPE_LWT_SEG6LOCAL,
|
||||
BPF_PROG_TYPE_LIRC_MODE2,
|
||||
};
|
||||
|
||||
enum bpf_attach_type {
|
||||
|
|
@ -162,6 +163,7 @@ enum bpf_attach_type {
|
|||
BPF_CGROUP_INET6_POST_BIND,
|
||||
BPF_CGROUP_UDP4_SENDMSG,
|
||||
BPF_CGROUP_UDP6_SENDMSG,
|
||||
BPF_LIRC_MODE2,
|
||||
__MAX_BPF_ATTACH_TYPE
|
||||
};
|
||||
|
||||
|
|
@ -1852,10 +1854,10 @@ union bpf_attr {
|
|||
* If lookup is successful and result shows packet is to be
|
||||
* forwarded, the neighbor tables are searched for the nexthop.
|
||||
* If successful (ie., FIB lookup shows forwarding and nexthop
|
||||
* is resolved), the nexthop address is returned in ipv4_dst,
|
||||
* ipv6_dst or mpls_out based on family, smac is set to mac
|
||||
* address of egress device, dmac is set to nexthop mac address,
|
||||
* rt_metric is set to metric from route.
|
||||
* is resolved), the nexthop address is returned in ipv4_dst
|
||||
* or ipv6_dst based on family, smac is set to mac address of
|
||||
* egress device, dmac is set to nexthop mac address, rt_metric
|
||||
* is set to metric from route (IPv4/IPv6 only).
|
||||
*
|
||||
* *plen* argument is the size of the passed in struct.
|
||||
* *flags* argument can be a combination of one or more of the
|
||||
|
|
@ -2005,6 +2007,53 @@ union bpf_attr {
|
|||
* direct packet access.
|
||||
* Return
|
||||
* 0 on success, or a negative error in case of failure.
|
||||
*
|
||||
* int bpf_rc_keydown(void *ctx, u32 protocol, u64 scancode, u32 toggle)
|
||||
* Description
|
||||
* This helper is used in programs implementing IR decoding, to
|
||||
* report a successfully decoded key press with *scancode*,
|
||||
* *toggle* value in the given *protocol*. The scancode will be
|
||||
* translated to a keycode using the rc keymap, and reported as
|
||||
* an input key down event. After a period a key up event is
|
||||
* generated. This period can be extended by calling either
|
||||
* **bpf_rc_keydown** () again with the same values, or calling
|
||||
* **bpf_rc_repeat** ().
|
||||
*
|
||||
* Some protocols include a toggle bit, in case the button was
|
||||
* released and pressed again between consecutive scancodes.
|
||||
*
|
||||
* The *ctx* should point to the lirc sample as passed into
|
||||
* the program.
|
||||
*
|
||||
* The *protocol* is the decoded protocol number (see
|
||||
* **enum rc_proto** for some predefined values).
|
||||
*
|
||||
* This helper is only available is the kernel was compiled with
|
||||
* the **CONFIG_BPF_LIRC_MODE2** configuration option set to
|
||||
* "**y**".
|
||||
*
|
||||
* Return
|
||||
* 0
|
||||
*
|
||||
* int bpf_rc_repeat(void *ctx)
|
||||
* Description
|
||||
* This helper is used in programs implementing IR decoding, to
|
||||
* report a successfully decoded repeat key message. This delays
|
||||
* the generation of a key up event for previously generated
|
||||
* key down event.
|
||||
*
|
||||
* Some IR protocols like NEC have a special IR message for
|
||||
* repeating last button, for when a button is held down.
|
||||
*
|
||||
* The *ctx* should point to the lirc sample as passed into
|
||||
* the program.
|
||||
*
|
||||
* This helper is only available is the kernel was compiled with
|
||||
* the **CONFIG_BPF_LIRC_MODE2** configuration option set to
|
||||
* "**y**".
|
||||
*
|
||||
* Return
|
||||
* 0
|
||||
*/
|
||||
#define __BPF_FUNC_MAPPER(FN) \
|
||||
FN(unspec), \
|
||||
|
|
@ -2083,7 +2132,9 @@ union bpf_attr {
|
|||
FN(lwt_push_encap), \
|
||||
FN(lwt_seg6_store_bytes), \
|
||||
FN(lwt_seg6_adjust_srh), \
|
||||
FN(lwt_seg6_action),
|
||||
FN(lwt_seg6_action), \
|
||||
FN(rc_repeat), \
|
||||
FN(rc_keydown),
|
||||
|
||||
/* integer value in 'imm' field of BPF_CALL instruction selects which helper
|
||||
* function eBPF program intends to call
|
||||
|
|
@ -2537,8 +2588,10 @@ struct bpf_raw_tracepoint_args {
|
|||
#define BPF_FIB_LOOKUP_OUTPUT BIT(1)
|
||||
|
||||
struct bpf_fib_lookup {
|
||||
/* input */
|
||||
__u8 family; /* network family, AF_INET, AF_INET6, AF_MPLS */
|
||||
/* input: network family for lookup (AF_INET, AF_INET6)
|
||||
* output: network family of egress nexthop
|
||||
*/
|
||||
__u8 family;
|
||||
|
||||
/* set if lookup is to consider L4 data - e.g., FIB rules */
|
||||
__u8 l4_protocol;
|
||||
|
|
@ -2554,22 +2607,20 @@ struct bpf_fib_lookup {
|
|||
__u8 tos; /* AF_INET */
|
||||
__be32 flowlabel; /* AF_INET6 */
|
||||
|
||||
/* output: metric of fib result */
|
||||
__u32 rt_metric;
|
||||
/* output: metric of fib result (IPv4/IPv6 only) */
|
||||
__u32 rt_metric;
|
||||
};
|
||||
|
||||
union {
|
||||
__be32 mpls_in;
|
||||
__be32 ipv4_src;
|
||||
__u32 ipv6_src[4]; /* in6_addr; network order */
|
||||
};
|
||||
|
||||
/* input to bpf_fib_lookup, *dst is destination address.
|
||||
* output: bpf_fib_lookup sets to gateway address
|
||||
/* input to bpf_fib_lookup, ipv{4,6}_dst is destination address in
|
||||
* network header. output: bpf_fib_lookup sets to gateway address
|
||||
* if FIB lookup returns gateway route
|
||||
*/
|
||||
union {
|
||||
/* return for MPLS lookups */
|
||||
__be32 mpls_out[4]; /* support up to 4 labels */
|
||||
__be32 ipv4_dst;
|
||||
__u32 ipv6_dst[4]; /* in6_addr; network order */
|
||||
};
|
||||
|
|
|
|||
|
|
@ -0,0 +1,217 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
|
||||
/*
|
||||
* lirc.h - linux infrared remote control header file
|
||||
* last modified 2010/07/13 by Jarod Wilson
|
||||
*/
|
||||
|
||||
#ifndef _LINUX_LIRC_H
|
||||
#define _LINUX_LIRC_H
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/ioctl.h>
|
||||
|
||||
#define PULSE_BIT 0x01000000
|
||||
#define PULSE_MASK 0x00FFFFFF
|
||||
|
||||
#define LIRC_MODE2_SPACE 0x00000000
|
||||
#define LIRC_MODE2_PULSE 0x01000000
|
||||
#define LIRC_MODE2_FREQUENCY 0x02000000
|
||||
#define LIRC_MODE2_TIMEOUT 0x03000000
|
||||
|
||||
#define LIRC_VALUE_MASK 0x00FFFFFF
|
||||
#define LIRC_MODE2_MASK 0xFF000000
|
||||
|
||||
#define LIRC_SPACE(val) (((val)&LIRC_VALUE_MASK) | LIRC_MODE2_SPACE)
|
||||
#define LIRC_PULSE(val) (((val)&LIRC_VALUE_MASK) | LIRC_MODE2_PULSE)
|
||||
#define LIRC_FREQUENCY(val) (((val)&LIRC_VALUE_MASK) | LIRC_MODE2_FREQUENCY)
|
||||
#define LIRC_TIMEOUT(val) (((val)&LIRC_VALUE_MASK) | LIRC_MODE2_TIMEOUT)
|
||||
|
||||
#define LIRC_VALUE(val) ((val)&LIRC_VALUE_MASK)
|
||||
#define LIRC_MODE2(val) ((val)&LIRC_MODE2_MASK)
|
||||
|
||||
#define LIRC_IS_SPACE(val) (LIRC_MODE2(val) == LIRC_MODE2_SPACE)
|
||||
#define LIRC_IS_PULSE(val) (LIRC_MODE2(val) == LIRC_MODE2_PULSE)
|
||||
#define LIRC_IS_FREQUENCY(val) (LIRC_MODE2(val) == LIRC_MODE2_FREQUENCY)
|
||||
#define LIRC_IS_TIMEOUT(val) (LIRC_MODE2(val) == LIRC_MODE2_TIMEOUT)
|
||||
|
||||
/* used heavily by lirc userspace */
|
||||
#define lirc_t int
|
||||
|
||||
/*** lirc compatible hardware features ***/
|
||||
|
||||
#define LIRC_MODE2SEND(x) (x)
|
||||
#define LIRC_SEND2MODE(x) (x)
|
||||
#define LIRC_MODE2REC(x) ((x) << 16)
|
||||
#define LIRC_REC2MODE(x) ((x) >> 16)
|
||||
|
||||
#define LIRC_MODE_RAW 0x00000001
|
||||
#define LIRC_MODE_PULSE 0x00000002
|
||||
#define LIRC_MODE_MODE2 0x00000004
|
||||
#define LIRC_MODE_SCANCODE 0x00000008
|
||||
#define LIRC_MODE_LIRCCODE 0x00000010
|
||||
|
||||
|
||||
#define LIRC_CAN_SEND_RAW LIRC_MODE2SEND(LIRC_MODE_RAW)
|
||||
#define LIRC_CAN_SEND_PULSE LIRC_MODE2SEND(LIRC_MODE_PULSE)
|
||||
#define LIRC_CAN_SEND_MODE2 LIRC_MODE2SEND(LIRC_MODE_MODE2)
|
||||
#define LIRC_CAN_SEND_LIRCCODE LIRC_MODE2SEND(LIRC_MODE_LIRCCODE)
|
||||
|
||||
#define LIRC_CAN_SEND_MASK 0x0000003f
|
||||
|
||||
#define LIRC_CAN_SET_SEND_CARRIER 0x00000100
|
||||
#define LIRC_CAN_SET_SEND_DUTY_CYCLE 0x00000200
|
||||
#define LIRC_CAN_SET_TRANSMITTER_MASK 0x00000400
|
||||
|
||||
#define LIRC_CAN_REC_RAW LIRC_MODE2REC(LIRC_MODE_RAW)
|
||||
#define LIRC_CAN_REC_PULSE LIRC_MODE2REC(LIRC_MODE_PULSE)
|
||||
#define LIRC_CAN_REC_MODE2 LIRC_MODE2REC(LIRC_MODE_MODE2)
|
||||
#define LIRC_CAN_REC_SCANCODE LIRC_MODE2REC(LIRC_MODE_SCANCODE)
|
||||
#define LIRC_CAN_REC_LIRCCODE LIRC_MODE2REC(LIRC_MODE_LIRCCODE)
|
||||
|
||||
#define LIRC_CAN_REC_MASK LIRC_MODE2REC(LIRC_CAN_SEND_MASK)
|
||||
|
||||
#define LIRC_CAN_SET_REC_CARRIER (LIRC_CAN_SET_SEND_CARRIER << 16)
|
||||
#define LIRC_CAN_SET_REC_DUTY_CYCLE (LIRC_CAN_SET_SEND_DUTY_CYCLE << 16)
|
||||
|
||||
#define LIRC_CAN_SET_REC_DUTY_CYCLE_RANGE 0x40000000
|
||||
#define LIRC_CAN_SET_REC_CARRIER_RANGE 0x80000000
|
||||
#define LIRC_CAN_GET_REC_RESOLUTION 0x20000000
|
||||
#define LIRC_CAN_SET_REC_TIMEOUT 0x10000000
|
||||
#define LIRC_CAN_SET_REC_FILTER 0x08000000
|
||||
|
||||
#define LIRC_CAN_MEASURE_CARRIER 0x02000000
|
||||
#define LIRC_CAN_USE_WIDEBAND_RECEIVER 0x04000000
|
||||
|
||||
#define LIRC_CAN_SEND(x) ((x)&LIRC_CAN_SEND_MASK)
|
||||
#define LIRC_CAN_REC(x) ((x)&LIRC_CAN_REC_MASK)
|
||||
|
||||
#define LIRC_CAN_NOTIFY_DECODE 0x01000000
|
||||
|
||||
/*** IOCTL commands for lirc driver ***/
|
||||
|
||||
#define LIRC_GET_FEATURES _IOR('i', 0x00000000, __u32)
|
||||
|
||||
#define LIRC_GET_SEND_MODE _IOR('i', 0x00000001, __u32)
|
||||
#define LIRC_GET_REC_MODE _IOR('i', 0x00000002, __u32)
|
||||
#define LIRC_GET_REC_RESOLUTION _IOR('i', 0x00000007, __u32)
|
||||
|
||||
#define LIRC_GET_MIN_TIMEOUT _IOR('i', 0x00000008, __u32)
|
||||
#define LIRC_GET_MAX_TIMEOUT _IOR('i', 0x00000009, __u32)
|
||||
|
||||
/* code length in bits, currently only for LIRC_MODE_LIRCCODE */
|
||||
#define LIRC_GET_LENGTH _IOR('i', 0x0000000f, __u32)
|
||||
|
||||
#define LIRC_SET_SEND_MODE _IOW('i', 0x00000011, __u32)
|
||||
#define LIRC_SET_REC_MODE _IOW('i', 0x00000012, __u32)
|
||||
/* Note: these can reset the according pulse_width */
|
||||
#define LIRC_SET_SEND_CARRIER _IOW('i', 0x00000013, __u32)
|
||||
#define LIRC_SET_REC_CARRIER _IOW('i', 0x00000014, __u32)
|
||||
#define LIRC_SET_SEND_DUTY_CYCLE _IOW('i', 0x00000015, __u32)
|
||||
#define LIRC_SET_TRANSMITTER_MASK _IOW('i', 0x00000017, __u32)
|
||||
|
||||
/*
|
||||
* when a timeout != 0 is set the driver will send a
|
||||
* LIRC_MODE2_TIMEOUT data packet, otherwise LIRC_MODE2_TIMEOUT is
|
||||
* never sent, timeout is disabled by default
|
||||
*/
|
||||
#define LIRC_SET_REC_TIMEOUT _IOW('i', 0x00000018, __u32)
|
||||
|
||||
/* 1 enables, 0 disables timeout reports in MODE2 */
|
||||
#define LIRC_SET_REC_TIMEOUT_REPORTS _IOW('i', 0x00000019, __u32)
|
||||
|
||||
/*
|
||||
* if enabled from the next key press on the driver will send
|
||||
* LIRC_MODE2_FREQUENCY packets
|
||||
*/
|
||||
#define LIRC_SET_MEASURE_CARRIER_MODE _IOW('i', 0x0000001d, __u32)
|
||||
|
||||
/*
|
||||
* to set a range use LIRC_SET_REC_CARRIER_RANGE with the
|
||||
* lower bound first and later LIRC_SET_REC_CARRIER with the upper bound
|
||||
*/
|
||||
#define LIRC_SET_REC_CARRIER_RANGE _IOW('i', 0x0000001f, __u32)
|
||||
|
||||
#define LIRC_SET_WIDEBAND_RECEIVER _IOW('i', 0x00000023, __u32)
|
||||
|
||||
/*
|
||||
* struct lirc_scancode - decoded scancode with protocol for use with
|
||||
* LIRC_MODE_SCANCODE
|
||||
*
|
||||
* @timestamp: Timestamp in nanoseconds using CLOCK_MONOTONIC when IR
|
||||
* was decoded.
|
||||
* @flags: should be 0 for transmit. When receiving scancodes,
|
||||
* LIRC_SCANCODE_FLAG_TOGGLE or LIRC_SCANCODE_FLAG_REPEAT can be set
|
||||
* depending on the protocol
|
||||
* @rc_proto: see enum rc_proto
|
||||
* @keycode: the translated keycode. Set to 0 for transmit.
|
||||
* @scancode: the scancode received or to be sent
|
||||
*/
|
||||
struct lirc_scancode {
|
||||
__u64 timestamp;
|
||||
__u16 flags;
|
||||
__u16 rc_proto;
|
||||
__u32 keycode;
|
||||
__u64 scancode;
|
||||
};
|
||||
|
||||
/* Set if the toggle bit of rc-5 or rc-6 is enabled */
|
||||
#define LIRC_SCANCODE_FLAG_TOGGLE 1
|
||||
/* Set if this is a nec or sanyo repeat */
|
||||
#define LIRC_SCANCODE_FLAG_REPEAT 2
|
||||
|
||||
/**
|
||||
* enum rc_proto - the Remote Controller protocol
|
||||
*
|
||||
* @RC_PROTO_UNKNOWN: Protocol not known
|
||||
* @RC_PROTO_OTHER: Protocol known but proprietary
|
||||
* @RC_PROTO_RC5: Philips RC5 protocol
|
||||
* @RC_PROTO_RC5X_20: Philips RC5x 20 bit protocol
|
||||
* @RC_PROTO_RC5_SZ: StreamZap variant of RC5
|
||||
* @RC_PROTO_JVC: JVC protocol
|
||||
* @RC_PROTO_SONY12: Sony 12 bit protocol
|
||||
* @RC_PROTO_SONY15: Sony 15 bit protocol
|
||||
* @RC_PROTO_SONY20: Sony 20 bit protocol
|
||||
* @RC_PROTO_NEC: NEC protocol
|
||||
* @RC_PROTO_NECX: Extended NEC protocol
|
||||
* @RC_PROTO_NEC32: NEC 32 bit protocol
|
||||
* @RC_PROTO_SANYO: Sanyo protocol
|
||||
* @RC_PROTO_MCIR2_KBD: RC6-ish MCE keyboard
|
||||
* @RC_PROTO_MCIR2_MSE: RC6-ish MCE mouse
|
||||
* @RC_PROTO_RC6_0: Philips RC6-0-16 protocol
|
||||
* @RC_PROTO_RC6_6A_20: Philips RC6-6A-20 protocol
|
||||
* @RC_PROTO_RC6_6A_24: Philips RC6-6A-24 protocol
|
||||
* @RC_PROTO_RC6_6A_32: Philips RC6-6A-32 protocol
|
||||
* @RC_PROTO_RC6_MCE: MCE (Philips RC6-6A-32 subtype) protocol
|
||||
* @RC_PROTO_SHARP: Sharp protocol
|
||||
* @RC_PROTO_XMP: XMP protocol
|
||||
* @RC_PROTO_CEC: CEC protocol
|
||||
* @RC_PROTO_IMON: iMon Pad protocol
|
||||
*/
|
||||
enum rc_proto {
|
||||
RC_PROTO_UNKNOWN = 0,
|
||||
RC_PROTO_OTHER = 1,
|
||||
RC_PROTO_RC5 = 2,
|
||||
RC_PROTO_RC5X_20 = 3,
|
||||
RC_PROTO_RC5_SZ = 4,
|
||||
RC_PROTO_JVC = 5,
|
||||
RC_PROTO_SONY12 = 6,
|
||||
RC_PROTO_SONY15 = 7,
|
||||
RC_PROTO_SONY20 = 8,
|
||||
RC_PROTO_NEC = 9,
|
||||
RC_PROTO_NECX = 10,
|
||||
RC_PROTO_NEC32 = 11,
|
||||
RC_PROTO_SANYO = 12,
|
||||
RC_PROTO_MCIR2_KBD = 13,
|
||||
RC_PROTO_MCIR2_MSE = 14,
|
||||
RC_PROTO_RC6_0 = 15,
|
||||
RC_PROTO_RC6_6A_20 = 16,
|
||||
RC_PROTO_RC6_6A_24 = 17,
|
||||
RC_PROTO_RC6_6A_32 = 18,
|
||||
RC_PROTO_RC6_MCE = 19,
|
||||
RC_PROTO_SHARP = 20,
|
||||
RC_PROTO_XMP = 21,
|
||||
RC_PROTO_CEC = 22,
|
||||
RC_PROTO_IMON = 23,
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1462,6 +1462,7 @@ static bool bpf_prog_type__needs_kver(enum bpf_prog_type type)
|
|||
case BPF_PROG_TYPE_CGROUP_DEVICE:
|
||||
case BPF_PROG_TYPE_SK_MSG:
|
||||
case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:
|
||||
case BPF_PROG_TYPE_LIRC_MODE2:
|
||||
return false;
|
||||
case BPF_PROG_TYPE_UNSPEC:
|
||||
case BPF_PROG_TYPE_KPROBE:
|
||||
|
|
|
|||
|
|
@ -17,3 +17,4 @@ test_sock_addr
|
|||
urandom_read
|
||||
test_btf
|
||||
test_sockmap
|
||||
test_lirc_mode2_user
|
||||
|
|
|
|||
|
|
@ -24,7 +24,7 @@ urandom_read: urandom_read.c
|
|||
# Order correspond to 'make run_tests' order
|
||||
TEST_GEN_PROGS = test_verifier test_tag test_maps test_lru_map test_lpm_map test_progs \
|
||||
test_align test_verifier_log test_dev_cgroup test_tcpbpf_user \
|
||||
test_sock test_btf test_sockmap
|
||||
test_sock test_btf test_sockmap test_lirc_mode2_user
|
||||
|
||||
TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test_obj_id.o \
|
||||
test_pkt_md_access.o test_xdp_redirect.o test_xdp_meta.o sockmap_parse_prog.o \
|
||||
|
|
@ -34,7 +34,7 @@ TEST_GEN_FILES = test_pkt_access.o test_xdp.o test_l4lb.o test_tcp_estats.o test
|
|||
sockmap_tcp_msg_prog.o connect4_prog.o connect6_prog.o test_adjust_tail.o \
|
||||
test_btf_haskv.o test_btf_nokv.o test_sockmap_kern.o test_tunnel_kern.o \
|
||||
test_get_stack_rawtp.o test_sockmap_kern.o test_sockhash_kern.o \
|
||||
test_lwt_seg6local.o sendmsg4_prog.o sendmsg6_prog.o
|
||||
test_lwt_seg6local.o sendmsg4_prog.o sendmsg6_prog.o test_lirc_mode2_kern.o
|
||||
|
||||
# Order correspond to 'make run_tests' order
|
||||
TEST_PROGS := test_kmod.sh \
|
||||
|
|
@ -44,7 +44,8 @@ TEST_PROGS := test_kmod.sh \
|
|||
test_offload.py \
|
||||
test_sock_addr.sh \
|
||||
test_tunnel.sh \
|
||||
test_lwt_seg6local.sh
|
||||
test_lwt_seg6local.sh \
|
||||
test_lirc_mode2.sh
|
||||
|
||||
# Compile but not part of 'make run_tests'
|
||||
TEST_GEN_PROGS_EXTENDED = test_libbpf_open test_sock_addr
|
||||
|
|
|
|||
|
|
@ -126,6 +126,11 @@ static int (*bpf_lwt_seg6_action)(void *ctx, unsigned int action, void *param,
|
|||
static int (*bpf_lwt_seg6_adjust_srh)(void *ctx, unsigned int offset,
|
||||
unsigned int len) =
|
||||
(void *) BPF_FUNC_lwt_seg6_adjust_srh;
|
||||
static int (*bpf_rc_repeat)(void *ctx) =
|
||||
(void *) BPF_FUNC_rc_repeat;
|
||||
static int (*bpf_rc_keydown)(void *ctx, unsigned int protocol,
|
||||
unsigned long long scancode, unsigned int toggle) =
|
||||
(void *) BPF_FUNC_rc_keydown;
|
||||
|
||||
/* llvm builtin functions that eBPF C program may use to
|
||||
* emit BPF_LD_ABS and BPF_LD_IND instructions
|
||||
|
|
|
|||
|
|
@ -0,0 +1,28 @@
|
|||
#!/bin/bash
|
||||
# SPDX-License-Identifier: GPL-2.0
|
||||
|
||||
GREEN='\033[0;92m'
|
||||
RED='\033[0;31m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
modprobe rc-loopback
|
||||
|
||||
for i in /sys/class/rc/rc*
|
||||
do
|
||||
if grep -q DRV_NAME=rc-loopback $i/uevent
|
||||
then
|
||||
LIRCDEV=$(grep DEVNAME= $i/lirc*/uevent | sed sQDEVNAME=Q/dev/Q)
|
||||
fi
|
||||
done
|
||||
|
||||
if [ -n $LIRCDEV ];
|
||||
then
|
||||
TYPE=lirc_mode2
|
||||
./test_lirc_mode2_user $LIRCDEV
|
||||
ret=$?
|
||||
if [ $ret -ne 0 ]; then
|
||||
echo -e ${RED}"FAIL: $TYPE"${NC}
|
||||
else
|
||||
echo -e ${GREEN}"PASS: $TYPE"${NC}
|
||||
fi
|
||||
fi
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
// test ir decoder
|
||||
//
|
||||
// Copyright (C) 2018 Sean Young <sean@mess.org>
|
||||
|
||||
#include <linux/bpf.h>
|
||||
#include <linux/lirc.h>
|
||||
#include "bpf_helpers.h"
|
||||
|
||||
SEC("lirc_mode2")
|
||||
int bpf_decoder(unsigned int *sample)
|
||||
{
|
||||
if (LIRC_IS_PULSE(*sample)) {
|
||||
unsigned int duration = LIRC_VALUE(*sample);
|
||||
|
||||
if (duration & 0x10000)
|
||||
bpf_rc_keydown(sample, 0x40, duration & 0xffff, 0);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
char _license[] SEC("license") = "GPL";
|
||||
|
|
@ -0,0 +1,149 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
// test ir decoder
|
||||
//
|
||||
// Copyright (C) 2018 Sean Young <sean@mess.org>
|
||||
|
||||
// A lirc chardev is a device representing a consumer IR (cir) device which
|
||||
// can receive infrared signals from remote control and/or transmit IR.
|
||||
//
|
||||
// IR is sent as a series of pulses and space somewhat like morse code. The
|
||||
// BPF program can decode this into scancodes so that rc-core can translate
|
||||
// this into input key codes using the rc keymap.
|
||||
//
|
||||
// This test works by sending IR over rc-loopback, so the IR is processed by
|
||||
// BPF and then decoded into scancodes. The lirc chardev must be the one
|
||||
// associated with rc-loopback, see the output of ir-keytable(1).
|
||||
//
|
||||
// The following CONFIG options must be enabled for the test to succeed:
|
||||
// CONFIG_RC_CORE=y
|
||||
// CONFIG_BPF_RAWIR_EVENT=y
|
||||
// CONFIG_RC_LOOPBACK=y
|
||||
|
||||
// Steps:
|
||||
// 1. Open the /dev/lircN device for rc-loopback (given on command line)
|
||||
// 2. Attach bpf_lirc_mode2 program which decodes some IR.
|
||||
// 3. Send some IR to the same IR device; since it is loopback, this will
|
||||
// end up in the bpf program
|
||||
// 4. bpf program should decode IR and report keycode
|
||||
// 5. We can read keycode from same /dev/lirc device
|
||||
|
||||
#include <linux/bpf.h>
|
||||
#include <linux/lirc.h>
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
#include <poll.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/ioctl.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#include "bpf_util.h"
|
||||
#include <bpf/bpf.h>
|
||||
#include <bpf/libbpf.h>
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct bpf_object *obj;
|
||||
int ret, lircfd, progfd, mode;
|
||||
int testir = 0x1dead;
|
||||
u32 prog_ids[10], prog_flags[10], prog_cnt;
|
||||
|
||||
if (argc != 2) {
|
||||
printf("Usage: %s /dev/lircN\n", argv[0]);
|
||||
return 2;
|
||||
}
|
||||
|
||||
ret = bpf_prog_load("test_lirc_mode2_kern.o",
|
||||
BPF_PROG_TYPE_LIRC_MODE2, &obj, &progfd);
|
||||
if (ret) {
|
||||
printf("Failed to load bpf program\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
lircfd = open(argv[1], O_RDWR | O_NONBLOCK);
|
||||
if (lircfd == -1) {
|
||||
printf("failed to open lirc device %s: %m\n", argv[1]);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Let's try detach it before it was ever attached */
|
||||
ret = bpf_prog_detach2(progfd, lircfd, BPF_LIRC_MODE2);
|
||||
if (ret != -1 || errno != ENOENT) {
|
||||
printf("bpf_prog_detach2 not attached should fail: %m\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
mode = LIRC_MODE_SCANCODE;
|
||||
if (ioctl(lircfd, LIRC_SET_REC_MODE, &mode)) {
|
||||
printf("failed to set rec mode: %m\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
prog_cnt = 10;
|
||||
ret = bpf_prog_query(lircfd, BPF_LIRC_MODE2, 0, prog_flags, prog_ids,
|
||||
&prog_cnt);
|
||||
if (ret) {
|
||||
printf("Failed to query bpf programs on lirc device: %m\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (prog_cnt != 0) {
|
||||
printf("Expected nothing to be attached\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
ret = bpf_prog_attach(progfd, lircfd, BPF_LIRC_MODE2, 0);
|
||||
if (ret) {
|
||||
printf("Failed to attach bpf to lirc device: %m\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Write raw IR */
|
||||
ret = write(lircfd, &testir, sizeof(testir));
|
||||
if (ret != sizeof(testir)) {
|
||||
printf("Failed to send test IR message: %m\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
struct pollfd pfd = { .fd = lircfd, .events = POLLIN };
|
||||
struct lirc_scancode lsc;
|
||||
|
||||
poll(&pfd, 1, 100);
|
||||
|
||||
/* Read decoded IR */
|
||||
ret = read(lircfd, &lsc, sizeof(lsc));
|
||||
if (ret != sizeof(lsc)) {
|
||||
printf("Failed to read decoded IR: %m\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (lsc.scancode != 0xdead || lsc.rc_proto != 64) {
|
||||
printf("Incorrect scancode decoded\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
prog_cnt = 10;
|
||||
ret = bpf_prog_query(lircfd, BPF_LIRC_MODE2, 0, prog_flags, prog_ids,
|
||||
&prog_cnt);
|
||||
if (ret) {
|
||||
printf("Failed to query bpf programs on lirc device: %m\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (prog_cnt != 1) {
|
||||
printf("Expected one program to be attached\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Let's try detaching it now it is actually attached */
|
||||
ret = bpf_prog_detach2(progfd, lircfd, BPF_LIRC_MODE2);
|
||||
if (ret) {
|
||||
printf("bpf_prog_detach2: returned %m\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
Loading…
Reference in New Issue