1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (c) 2024 José Expósito
3 */
4
5 #include "vmlinux.h"
6 #include "hid_bpf.h"
7 #include "hid_bpf_helpers.h"
8 #include <bpf/bpf_tracing.h>
9
10 #define VID_UGEE 0x28BD
11 #define PID_DECO_MINI_4 0x0929
12 #define RDESC_SIZE_PAD 177
13 #define RDESC_SIZE_PEN 109
14 #define PAD_REPORT_ID 0x06
15
16 /*
17 * XP-Pen devices return a descriptor with the values the driver should use when
18 * one of its interfaces is queried. For this device the descriptor is:
19 *
20 * 0E 03 60 4F 88 3B 06 00 FF 1F D8 13
21 * ----- ----- ----- -----
22 * | | | |
23 * | | | `- Resolution: 5080 (13d8)
24 * | | `- Maximum pressure: 8191 (1FFF)
25 * | `- Logical maximum Y: 15240 (3B88)
26 * `- Logical maximum X: 20320 (4F60)
27 *
28 * The physical maximum is calculated as (logical_max * 1000) / resolution.
29 */
30 #define LOGICAL_MAX_X 0x60, 0x4F
31 #define LOGICAL_MAX_Y 0x88, 0x3B
32 #define PHYSICAL_MAX_X 0xA0, 0x0F
33 #define PHYSICAL_MAX_Y 0xB8, 0x0B
34 #define PRESSURE_MAX 0xFF, 0x1F
35
36 HID_BPF_CONFIG(
37 HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, VID_UGEE, PID_DECO_MINI_4)
38 );
39
40 /*
41 * The tablet send these values when the pad buttons are pressed individually:
42 *
43 * Buttons released: 06 00 00 00 00 00 00 00
44 * Button 1: 06 00 05 00 00 00 00 00 -> b
45 * Button 2: 06 00 08 00 00 00 00 00 -> e
46 * Button 3: 06 04 00 00 00 00 00 00 -> LAlt
47 * Button 4: 06 00 2c 00 00 00 00 00 -> Space
48 * Button 5: 06 01 16 00 00 00 00 00 -> LControl + s
49 * Button 6: 06 01 1d 00 00 00 00 00 -> LControl + z
50 *
51 * When multiple buttons are pressed at the same time, the values used to
52 * identify the buttons are identical, but they appear in different bytes of the
53 * record. For example, when button 2 (0x08) and button 1 (0x05) are pressed,
54 * this is the report:
55 *
56 * Buttons 2 and 1: 06 00 08 05 00 00 00 00 -> e + b
57 *
58 * Buttons 1, 2, 4, 5 and 6 can be matched by finding their values in the
59 * report.
60 *
61 * Button 3 is pressed when the 3rd bit is 1. For example, pressing buttons 3
62 * and 5 generates this report:
63 *
64 * Buttons 3 and 5: 06 05 16 00 00 00 00 00 -> LControl + LAlt + s
65 * -- --
66 * | |
67 * | `- Button 5 (0x16)
68 * `- 0x05 = 0101. Button 3 is pressed
69 * ^
70 *
71 * pad_buttons contains a list of buttons that can be matched in
72 * HID_BPF_DEVICE_EVENT. Button 3 as it has a dedicated bit.
73 */
74 static const __u8 pad_buttons[] = { 0x05, 0x08, 0x00, 0x2C, 0x16, 0x1D };
75
76 static const __u8 fixed_pad_rdesc[] = {
77 0x05, 0x01, /* Usage Page (Desktop), */
78 0x09, 0x07, /* Usage (Keypad), */
79 0xA1, 0x01, /* Collection (Application), */
80 0x85, 0x06, /* Report ID (6), */
81 0x05, 0x0D, /* Usage Page (Digitizer), */
82 0x09, 0x39, /* Usage (Tablet Function Keys), */
83 0xA0, /* Collection (Physical), */
84 0x05, 0x09, /* Usage Page (Button), */
85 0x75, 0x01, /* Report Size (1), */
86 0x95, 0x06, /* Report Count (6), */
87 0x19, 0x01, /* Usage Minimum (01h), */
88 0x29, 0x06, /* Usage Maximum (06h), */
89 0x14, /* Logical Minimum (0), */
90 0x25, 0x01, /* Logical Maximum (1), */
91 0x81, 0x02, /* Input (Variable), */
92 0x95, 0x32, /* Report Count (50), */
93 0x81, 0x01, /* Input (Constant), */
94 0xC0, /* End Collection, */
95 0xC0 /* End Collection */
96 };
97
98 static const __u8 fixed_pen_rdesc[] = {
99 0x05, 0x0d, /* Usage Page (Digitizers), */
100 0x09, 0x01, /* Usage (Digitizer), */
101 0xa1, 0x01, /* Collection (Application), */
102 0x85, 0x07, /* Report ID (7), */
103 0x09, 0x20, /* Usage (Stylus), */
104 0xa1, 0x00, /* Collection (Physical), */
105 0x09, 0x42, /* Usage (Tip Switch), */
106 0x09, 0x44, /* Usage (Barrel Switch), */
107 0x09, 0x46, /* Usage (Tablet Pick), */
108 0x75, 0x01, /* Report Size (1), */
109 0x95, 0x03, /* Report Count (3), */
110 0x14, /* Logical Minimum (0), */
111 0x25, 0x01, /* Logical Maximum (1), */
112 0x81, 0x02, /* Input (Variable), */
113 0x95, 0x02, /* Report Count (2), */
114 0x81, 0x03, /* Input (Constant, Variable), */
115 0x09, 0x32, /* Usage (In Range), */
116 0x95, 0x01, /* Report Count (1), */
117 0x81, 0x02, /* Input (Variable), */
118 0x95, 0x02, /* Report Count (2), */
119 0x81, 0x03, /* Input (Constant, Variable), */
120 0x75, 0x10, /* Report Size (16), */
121 0x95, 0x01, /* Report Count (1), */
122 0x35, 0x00, /* Physical Minimum (0), */
123 0xa4, /* Push, */
124 0x05, 0x01, /* Usage Page (Desktop), */
125 0x09, 0x30, /* Usage (X), */
126 0x65, 0x13, /* Unit (Inch), */
127 0x55, 0x0d, /* Unit Exponent (-3), */
128 0x26, LOGICAL_MAX_X, /* Logical Maximum, */
129 0x46, PHYSICAL_MAX_X, /* Physical Maximum, */
130 0x81, 0x02, /* Input (Variable), */
131 0x09, 0x31, /* Usage (Y), */
132 0x26, LOGICAL_MAX_Y, /* Logical Maximum, */
133 0x46, PHYSICAL_MAX_Y, /* Physical Maximum, */
134 0x81, 0x02, /* Input (Variable), */
135 0xb4, /* Pop, */
136 0x09, 0x30, /* Usage (Tip Pressure), */
137 0x45, 0x00, /* Physical Maximum (0), */
138 0x26, PRESSURE_MAX, /* Logical Maximum, */
139 0x75, 0x0D, /* Report Size (13), */
140 0x95, 0x01, /* Report Count (1), */
141 0x81, 0x02, /* Input (Variable), */
142 0x75, 0x01, /* Report Size (1), */
143 0x95, 0x13, /* Report Count (19), */
144 0x81, 0x01, /* Input (Constant), */
145 0xc0, /* End Collection, */
146 0xc0, /* End Collection */
147 };
148
149 static const size_t fixed_pad_rdesc_size = sizeof(fixed_pad_rdesc);
150 static const size_t fixed_pen_rdesc_size = sizeof(fixed_pen_rdesc);
151
SEC(HID_BPF_RDESC_FIXUP)152 SEC(HID_BPF_RDESC_FIXUP)
153 int BPF_PROG(hid_rdesc_fixup_xppen_deco_mini_4, struct hid_bpf_ctx *hctx)
154 {
155 __u8 *data = hid_bpf_get_data(hctx, 0, HID_MAX_DESCRIPTOR_SIZE);
156
157 if (!data)
158 return 0; /* EPERM check */
159
160 if (hctx->size == RDESC_SIZE_PAD) {
161 __builtin_memcpy(data, fixed_pad_rdesc, fixed_pad_rdesc_size);
162 return fixed_pad_rdesc_size;
163 } else if (hctx->size == RDESC_SIZE_PEN) {
164 __builtin_memcpy(data, fixed_pen_rdesc, fixed_pen_rdesc_size);
165 return fixed_pen_rdesc_size;
166 }
167
168 return 0;
169 }
170
SEC(HID_BPF_DEVICE_EVENT)171 SEC(HID_BPF_DEVICE_EVENT)
172 int BPF_PROG(hid_device_event_xppen_deco_mini_4, struct hid_bpf_ctx *hctx)
173 {
174 __u8 *data = hid_bpf_get_data(hctx, 0 /* offset */, 8 /* size */);
175 __u8 button_mask = 0;
176 int d, b;
177
178 if (!data)
179 return 0; /* EPERM check */
180
181 if (data[0] != PAD_REPORT_ID)
182 return 0;
183
184 /* data[1] stores the status of BTN_2 in the 3rd bit*/
185 if (data[1] & BIT(2))
186 button_mask |= BIT(2);
187
188 /* The rest of the descriptor stores the buttons as in pad_buttons */
189 for (d = 2; d < 8; d++) {
190 for (b = 0; b < sizeof(pad_buttons); b++) {
191 if (data[d] != 0 && data[d] == pad_buttons[b])
192 button_mask |= BIT(b);
193 }
194 }
195
196 __u8 report[8] = {PAD_REPORT_ID, button_mask, 0x00};
197
198 __builtin_memcpy(data, report, sizeof(report));
199
200 return 0;
201 }
202
203 HID_BPF_OPS(deco_mini_4) = {
204 .hid_device_event = (void *)hid_device_event_xppen_deco_mini_4,
205 .hid_rdesc_fixup = (void *)hid_rdesc_fixup_xppen_deco_mini_4,
206 };
207
208 SEC("syscall")
probe(struct hid_bpf_probe_args * ctx)209 int probe(struct hid_bpf_probe_args *ctx)
210 {
211 /*
212 * The device has 2 modes: The compatibility mode, enabled by default,
213 * and the raw mode, that can be activated by sending a buffer of magic
214 * data to a certain USB endpoint.
215 *
216 * Depending on the mode, different interfaces of the device are used:
217 * - First interface: Pad in compatibility mode
218 * - Second interface: Pen in compatibility mode
219 * - Third interface: Only used in raw mode
220 *
221 * We'll use the device in compatibility mode.
222 */
223 ctx->retval = ctx->rdesc_size != RDESC_SIZE_PAD &&
224 ctx->rdesc_size != RDESC_SIZE_PEN;
225 if (ctx->retval)
226 ctx->retval = -EINVAL;
227
228 return 0;
229 }
230
231 char _license[] SEC("license") = "GPL";
232