Commit a56a2569 authored by Benjamin Tissoires's avatar Benjamin Tissoires Committed by Jiri Kosina
Browse files

samples/hid: add Surface Dial example 



Add a more complete HID-BPF example.

Signed-off-by: default avatarBenjamin Tissoires <benjamin.tissoires@redhat.com>
Signed-off-by: default avatarJiri Kosina <jkosina@suse.cz>
parent 6008105b

samples/hid/.gitignore

+1 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only

hid_mouse

hid_surface_dial

*.out

*.skel.h

/vmlinux.h

samples/hid/Makefile

+5 −1
Original line number Diff line number Diff line
@@ -7,6 +7,7 @@ pound := \# 


# List of programs to build

tprogs-y += hid_mouse

tprogs-y += hid_surface_dial



# Libbpf dependencies

LIBBPF_SRC = $(TOOLS_PATH)/lib/bpf
@@ -19,6 +20,7 @@ EXTRA_HEADERS := hid_bpf_attach.h 
EXTRA_BPF_HEADERS := hid_bpf_helpers.h



hid_mouse-objs := hid_mouse.o

hid_surface_dial-objs := hid_surface_dial.o



# Tell kbuild to always build the programs

always-y := $(tprogs-y)
@@ -156,6 +158,7 @@ libbpf_hdrs: $(LIBBPF) 
.PHONY: libbpf_hdrs



$(obj)/hid_mouse.o: $(obj)/hid_mouse.skel.h

$(obj)/hid_surface_dial.o: $(obj)/hid_surface_dial.skel.h



-include $(HID_SAMPLES_PATH)/Makefile.target
@@ -201,10 +204,11 @@ $(obj)/%.bpf.o: $(src)/%.bpf.c $(EXTRA_BPF_HEADERS_SRC) $(obj)/vmlinux.h 
		-I$(LIBBPF_INCLUDE) $(CLANG_SYS_INCLUDES) \

		-c $(filter %.bpf.c,$^) -o $@



LINKED_SKELS := hid_mouse.skel.h

LINKED_SKELS := hid_mouse.skel.h hid_surface_dial.skel.h

clean-files += $(LINKED_SKELS)



hid_mouse.skel.h-deps := hid_mouse.bpf.o hid_bpf_attach.bpf.o

hid_surface_dial.skel.h-deps := hid_surface_dial.bpf.o hid_bpf_attach.bpf.o



LINKED_BPF_SRCS := $(patsubst %.bpf.o,%.bpf.c,$(foreach skel,$(LINKED_SKELS),$($(skel)-deps)))

samples/hid/hid_bpf_helpers.h

+2 −0
Original line number Diff line number Diff line
@@ -10,6 +10,8 @@ extern __u8 *hid_bpf_get_data(struct hid_bpf_ctx *ctx, 
			      unsigned int offset,

			      const size_t __sz) __ksym;

extern int hid_bpf_attach_prog(unsigned int hid_id, int prog_fd, u32 flags) __ksym;

extern struct hid_bpf_ctx *hid_bpf_allocate_context(unsigned int hid_id) __ksym;

extern void hid_bpf_release_context(struct hid_bpf_ctx *ctx) __ksym;

extern int hid_bpf_hw_request(struct hid_bpf_ctx *ctx,

			      __u8 *data,

			      size_t buf__sz,

samples/hid/hid_surface_dial.bpf.c

0 → 100644
+134 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/* Copyright (c) 2022 Benjamin Tissoires

 */



#include "vmlinux.h"

#include <bpf/bpf_helpers.h>

#include <bpf/bpf_tracing.h>

#include "hid_bpf_helpers.h"



#define HID_UP_BUTTON		0x0009

#define HID_GD_WHEEL		0x0038



SEC("fmod_ret/hid_bpf_device_event")

int BPF_PROG(hid_event, struct hid_bpf_ctx *hctx)

{

	__u8 *data = hid_bpf_get_data(hctx, 0 /* offset */, 9 /* size */);



	if (!data)

		return 0; /* EPERM check */



	/* Touch */

	data[1] &= 0xfd;



	/* X */

	data[4] = 0;

	data[5] = 0;



	/* Y */

	data[6] = 0;

	data[7] = 0;



	return 0;

}



/* 72 == 360 / 5 -> 1 report every 5 degrees */

int resolution = 72;

int physical = 5;



struct haptic_syscall_args {

	unsigned int hid;

	int retval;

};



static __u8 haptic_data[8];



SEC("syscall")

int set_haptic(struct haptic_syscall_args *args)

{

	struct hid_bpf_ctx *ctx;

	const size_t size = sizeof(haptic_data);

	u16 *res;

	int ret;



	if (size > sizeof(haptic_data))

		return -7; /* -E2BIG */



	ctx = hid_bpf_allocate_context(args->hid);

	if (!ctx)

		return -1; /* EPERM check */



	haptic_data[0] = 1;  /* report ID */



	ret = hid_bpf_hw_request(ctx, haptic_data, size, HID_FEATURE_REPORT, HID_REQ_GET_REPORT);



	bpf_printk("probed/remove event ret value: %d", ret);

	bpf_printk("buf: %02x %02x %02x",

		   haptic_data[0],

		   haptic_data[1],

		   haptic_data[2]);

	bpf_printk("     %02x %02x %02x",

		   haptic_data[3],

		   haptic_data[4],

		   haptic_data[5]);

	bpf_printk("     %02x %02x",

		   haptic_data[6],

		   haptic_data[7]);



	/* whenever resolution multiplier is not 3600, we have the fixed report descriptor */

	res = (u16 *)&haptic_data[1];

	if (*res != 3600) {

//		haptic_data[1] = 72; /* resolution multiplier */

//		haptic_data[2] = 0;  /* resolution multiplier */

//		haptic_data[3] = 0;  /* Repeat Count */

		haptic_data[4] = 3;  /* haptic Auto Trigger */

//		haptic_data[5] = 5;  /* Waveform Cutoff Time */

//		haptic_data[6] = 80; /* Retrigger Period */

//		haptic_data[7] = 0;  /* Retrigger Period */

	} else {

		haptic_data[4] = 0;

	}



	ret = hid_bpf_hw_request(ctx, haptic_data, size, HID_FEATURE_REPORT, HID_REQ_SET_REPORT);



	bpf_printk("set haptic ret value: %d -> %d", ret, haptic_data[4]);



	args->retval = ret;



	hid_bpf_release_context(ctx);



	return 0;

}



/* Convert REL_DIAL into REL_WHEEL */

SEC("fmod_ret/hid_bpf_rdesc_fixup")

int BPF_PROG(hid_rdesc_fixup, struct hid_bpf_ctx *hctx)

{

	__u8 *data = hid_bpf_get_data(hctx, 0 /* offset */, 4096 /* size */);

	__u16 *res, *phys;



	if (!data)

		return 0; /* EPERM check */



	/* Convert TOUCH into a button */

	data[31] = HID_UP_BUTTON;

	data[33] = 2;



	/* Convert REL_DIAL into REL_WHEEL */

	data[45] = HID_GD_WHEEL;



	/* Change Resolution Multiplier */

	phys = (__u16 *)&data[61];

	*phys = physical;

	res = (__u16 *)&data[66];

	*res = resolution;



	/* Convert X,Y from Abs to Rel */

	data[88] = 0x06;

	data[98] = 0x06;



	return 0;

}



char _license[] SEC("license") = "GPL";

u32 _version SEC("version") = 1;

samples/hid/hid_surface_dial.c

0 → 100644
+226 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/* Copyright (c) 2022 Benjamin Tissoires

 *

 * This program will morph the Microsoft Surface Dial into a mouse,

 * and depending on the chosen resolution enable or not the haptic feedback:

 * - a resolution (-r) of 3600 will report 3600 "ticks" in one full rotation

 *   wihout haptic feedback

 * - any other resolution will report N "ticks" in a full rotation with haptic

 *   feedback

 *

 * A good default for low resolution haptic scrolling is 72 (1 "tick" every 5

 * degrees), and set to 3600 for smooth scrolling.

 */



#include <assert.h>

#include <errno.h>

#include <fcntl.h>

#include <libgen.h>

#include <signal.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <sys/resource.h>

#include <unistd.h>



#include <linux/bpf.h>

#include <linux/errno.h>



#include <bpf/bpf.h>

#include <bpf/libbpf.h>



#include "hid_surface_dial.skel.h"

#include "hid_bpf_attach.h"



static bool running = true;



struct haptic_syscall_args {

	unsigned int hid;

	int retval;

};



static void int_exit(int sig)

{

	running = false;

	exit(0);

}



static void usage(const char *prog)

{

	fprintf(stderr,

		"%s: %s [OPTIONS] /sys/bus/hid/devices/0BUS:0VID:0PID:00ID\n\n"

		"  OPTIONS:\n"

		"    -r N\t set the given resolution to the device (number of ticks per 360°)\n\n",

		__func__, prog);

	fprintf(stderr,

		"This program will morph the Microsoft Surface Dial into a mouse,\n"

		"and depending on the chosen resolution enable or not the haptic feedback:\n"

		"- a resolution (-r) of 3600 will report 3600 'ticks' in one full rotation\n"

		"  wihout haptic feedback\n"

		"- any other resolution will report N 'ticks' in a full rotation with haptic\n"

		"  feedback\n"

		"\n"

		"A good default for low resolution haptic scrolling is 72 (1 'tick' every 5\n"

		"degrees), and set to 3600 for smooth scrolling.\n");

}



static int get_hid_id(const char *path)

{

	const char *str_id, *dir;

	char uevent[1024];

	int fd;



	memset(uevent, 0, sizeof(uevent));

	snprintf(uevent, sizeof(uevent) - 1, "%s/uevent", path);



	fd = open(uevent, O_RDONLY | O_NONBLOCK);

	if (fd < 0)

		return -ENOENT;



	close(fd);



	dir = basename((char *)path);



	str_id = dir + sizeof("0003:0001:0A37.");

	return (int)strtol(str_id, NULL, 16);

}



static int attach_prog(struct hid_surface_dial *skel, struct bpf_program *prog, int hid_id)

{

	struct attach_prog_args args = {

		.hid = hid_id,

		.retval = -1,

	};

	int attach_fd, err;

	DECLARE_LIBBPF_OPTS(bpf_test_run_opts, tattr,

			    .ctx_in = &args,

			    .ctx_size_in = sizeof(args),

	);



	attach_fd = bpf_program__fd(skel->progs.attach_prog);

	if (attach_fd < 0) {

		fprintf(stderr, "can't locate attach prog: %m\n");

		return 1;

	}



	args.prog_fd = bpf_program__fd(prog);

	err = bpf_prog_test_run_opts(attach_fd, &tattr);

	if (err) {

		fprintf(stderr, "can't attach prog to hid device %d: %m (err: %d)\n",

			hid_id, err);

		return 1;

	}

	return 0;

}



static int set_haptic(struct hid_surface_dial *skel, int hid_id)

{

	struct haptic_syscall_args args = {

		.hid = hid_id,

		.retval = -1,

	};

	int haptic_fd, err;

	DECLARE_LIBBPF_OPTS(bpf_test_run_opts, tattr,

			    .ctx_in = &args,

			    .ctx_size_in = sizeof(args),

	);



	haptic_fd = bpf_program__fd(skel->progs.set_haptic);

	if (haptic_fd < 0) {

		fprintf(stderr, "can't locate haptic prog: %m\n");

		return 1;

	}



	err = bpf_prog_test_run_opts(haptic_fd, &tattr);

	if (err) {

		fprintf(stderr, "can't set haptic configuration to hid device %d: %m (err: %d)\n",

			hid_id, err);

		return 1;

	}

	return 0;

}



int main(int argc, char **argv)

{

	struct hid_surface_dial *skel;

	struct bpf_program *prog;

	const char *optstr = "r:";

	const char *sysfs_path;

	int opt, hid_id, resolution = 72;



	while ((opt = getopt(argc, argv, optstr)) != -1) {

		switch (opt) {

		case 'r':

			{

				char *endp = NULL;

				long l = -1;



				if (optarg) {

					l = strtol(optarg, &endp, 10);

					if (endp && *endp)

						l = -1;

				}



				if (l < 0) {

					fprintf(stderr,

						"invalid r option %s - expecting a number\n",

						optarg ? optarg : "");

					exit(EXIT_FAILURE);

				};



				resolution = (int) l;

				break;

			}

		default:

			usage(basename(argv[0]));

			return 1;

		}

	}



	if (optind == argc) {

		usage(basename(argv[0]));

		return 1;

	}



	sysfs_path = argv[optind];

	if (!sysfs_path) {

		perror("sysfs");

		return 1;

	}



	skel = hid_surface_dial__open_and_load();

	if (!skel) {

		fprintf(stderr, "%s  %s:%d", __func__, __FILE__, __LINE__);

		return -1;

	}



	hid_id = get_hid_id(sysfs_path);

	if (hid_id < 0) {

		fprintf(stderr, "can not open HID device: %m\n");

		return 1;

	}



	skel->data->resolution = resolution;

	skel->data->physical = (int)(resolution / 72);



	bpf_object__for_each_program(prog, *skel->skeleton->obj) {

		/* ignore syscalls */

		if (bpf_program__get_type(prog) != BPF_PROG_TYPE_TRACING)

			continue;



		attach_prog(skel, prog, hid_id);

	}



	signal(SIGINT, int_exit);

	signal(SIGTERM, int_exit);



	set_haptic(skel, hid_id);



	while (running)

		sleep(1);



	hid_surface_dial__destroy(skel);



	return 0;

}