samples/hid/hid_surface_dial.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /* Copyright (c) 2022 Benjamin Tissoires
   3  *
   4  * This program will morph the Microsoft Surface Dial into a mouse,
   5  * and depending on the chosen resolution enable or not the haptic feedback:
   6  * - a resolution (-r) of 3600 will report 3600 "ticks" in one full rotation
   7  *   without haptic feedback
   8  * - any other resolution will report N "ticks" in a full rotation with haptic
   9  *   feedback
  10  *
  11  * A good default for low resolution haptic scrolling is 72 (1 "tick" every 5
  12  * degrees), and set to 3600 for smooth scrolling.
  13  */
  14
  15 #include <assert.h>
  16 #include <errno.h>
  17 #include <fcntl.h>
  18 #include <libgen.h>
  19 #include <signal.h>
  20 #include <stdbool.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/resource.h>
  25 #include <unistd.h>
  26
  27 #include <linux/bpf.h>
  28 #include <linux/errno.h>
  29
  30 #include <bpf/bpf.h>
  31 #include <bpf/libbpf.h>
  32
  33 #include "hid_surface_dial.skel.h"
  34 #include "hid_bpf_attach.h"
  35
  36 static bool running = true;
  37
  38 struct haptic_syscall_args {
  39         unsigned int hid;
  40         int retval;
  41 };
  42
  43 static void int_exit(int sig)
  44 {
  45         running = false;
  46         exit(0);
  47 }
  48
  49 static void usage(const char *prog)
  50 {
  51         fprintf(stderr,
  52                 "%s: %s [OPTIONS] /sys/bus/hid/devices/0BUS:0VID:0PID:00ID\n\n"
  53                 "  OPTIONS:\n"
  54                 "    -r N\t set the given resolution to the device (number of ticks per 360°)\n\n",
  55                 __func__, prog);
  56         fprintf(stderr,
  57                 "This program will morph the Microsoft Surface Dial into a mouse,\n"
  58                 "and depending on the chosen resolution enable or not the haptic feedback:\n"
  59                 "- a resolution (-r) of 3600 will report 3600 'ticks' in one full rotation\n"
  60                 "  without haptic feedback\n"
  61                 "- any other resolution will report N 'ticks' in a full rotation with haptic\n"
  62                 "  feedback\n"
  63                 "\n"
  64                 "A good default for low resolution haptic scrolling is 72 (1 'tick' every 5\n"
  65                 "degrees), and set to 3600 for smooth scrolling.\n");
  66 }
  67
  68 static int get_hid_id(const char *path)
  69 {
  70         const char *str_id, *dir;
  71         char uevent[1024];
  72         int fd;
  73
  74         memset(uevent, 0, sizeof(uevent));
  75         snprintf(uevent, sizeof(uevent) - 1, "%s/uevent", path);
  76
  77         fd = open(uevent, O_RDONLY | O_NONBLOCK);
  78         if (fd < 0)
  79                 return -ENOENT;
  80
  81         close(fd);
  82
  83         dir = basename((char *)path);
  84
  85         str_id = dir + sizeof("0003:0001:0A37.");
  86         return (int)strtol(str_id, NULL, 16);
  87 }
  88
  89 static int attach_prog(struct hid_surface_dial *skel, struct bpf_program *prog, int hid_id)
  90 {
  91         struct attach_prog_args args = {
  92                 .hid = hid_id,
  93                 .retval = -1,
  94         };
  95         int attach_fd, err;
  96         DECLARE_LIBBPF_OPTS(bpf_test_run_opts, tattr,
  97                             .ctx_in = &args,
  98                             .ctx_size_in = sizeof(args),
  99         );
 100
 101         attach_fd = bpf_program__fd(skel->progs.attach_prog);
 102         if (attach_fd < 0) {
 103                 fprintf(stderr, "can't locate attach prog: %m\n");
 104                 return 1;
 105         }
 106
 107         args.prog_fd = bpf_program__fd(prog);
 108         err = bpf_prog_test_run_opts(attach_fd, &tattr);
 109         if (err) {
 110                 fprintf(stderr, "can't attach prog to hid device %d: %m (err: %d)\n",
 111                         hid_id, err);
 112                 return 1;
 113         }
 114         return 0;
 115 }
 116
 117 static int set_haptic(struct hid_surface_dial *skel, int hid_id)
 118 {
 119         struct haptic_syscall_args args = {
 120                 .hid = hid_id,
 121                 .retval = -1,
 122         };
 123         int haptic_fd, err;
 124         DECLARE_LIBBPF_OPTS(bpf_test_run_opts, tattr,
 125                             .ctx_in = &args,
 126                             .ctx_size_in = sizeof(args),
 127         );
 128
 129         haptic_fd = bpf_program__fd(skel->progs.set_haptic);
 130         if (haptic_fd < 0) {
 131                 fprintf(stderr, "can't locate haptic prog: %m\n");
 132                 return 1;
 133         }
 134
 135         err = bpf_prog_test_run_opts(haptic_fd, &tattr);
 136         if (err) {
 137                 fprintf(stderr, "can't set haptic configuration to hid device %d: %m (err: %d)\n",
 138                         hid_id, err);
 139                 return 1;
 140         }
 141         return 0;
 142 }
 143
 144 int main(int argc, char **argv)
 145 {
 146         struct hid_surface_dial *skel;
 147         struct bpf_program *prog;
 148         const char *optstr = "r:";
 149         const char *sysfs_path;
 150         int opt, hid_id, resolution = 72;
 151
 152         while ((opt = getopt(argc, argv, optstr)) != -1) {
 153                 switch (opt) {
 154                 case 'r':
 155                         {
 156                                 char *endp = NULL;
 157                                 long l = -1;
 158
 159                                 if (optarg) {
 160                                         l = strtol(optarg, &endp, 10);
 161                                         if (endp && *endp)
 162                                                 l = -1;
 163                                 }
 164
 165                                 if (l < 0) {
 166                                         fprintf(stderr,
 167                                                 "invalid r option %s - expecting a number\n",
 168                                                 optarg ? optarg : "");
 169                                         exit(EXIT_FAILURE);
 170                                 };
 171
 172                                 resolution = (int) l;
 173                                 break;
 174                         }
 175                 default:
 176                         usage(basename(argv[0]));
 177                         return 1;
 178                 }
 179         }
 180
 181         if (optind == argc) {
 182                 usage(basename(argv[0]));
 183                 return 1;
 184         }
 185
 186         sysfs_path = argv[optind];
 187         if (!sysfs_path) {
 188                 perror("sysfs");
 189                 return 1;
 190         }
 191
 192         skel = hid_surface_dial__open_and_load();
 193         if (!skel) {
 194                 fprintf(stderr, "%s  %s:%d", __func__, __FILE__, __LINE__);
 195                 return -1;
 196         }
 197
 198         hid_id = get_hid_id(sysfs_path);
 199         if (hid_id < 0) {
 200                 fprintf(stderr, "can not open HID device: %m\n");
 201                 return 1;
 202         }
 203
 204         skel->data->resolution = resolution;
 205         skel->data->physical = (int)(resolution / 72);
 206
 207         bpf_object__for_each_program(prog, *skel->skeleton->obj) {
 208                 /* ignore syscalls */
 209                 if (bpf_program__get_type(prog) != BPF_PROG_TYPE_TRACING)
 210                         continue;
 211
 212                 attach_prog(skel, prog, hid_id);
 213         }
 214
 215         signal(SIGINT, int_exit);
 216         signal(SIGTERM, int_exit);
 217
 218         set_haptic(skel, hid_id);
 219
 220         while (running)
 221                 sleep(1);
 222
 223         hid_surface_dial__destroy(skel);
 224
 225         return 0;
 226 }