1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * HID UNIVERSAL PIDFF
4 * hid-pidff wrapper for PID-enabled devices
5 * Handles device reports, quirks and extends usable button range
6 *
7 * Copyright (c) 2024, 2025 Makarenko Oleg
8 * Copyright (c) 2024, 2025 Tomasz Pakuła
9 */
10
11 #include <linux/device.h>
12 #include <linux/hid.h>
13 #include <linux/module.h>
14 #include <linux/input-event-codes.h>
15 #include "hid-ids.h"
16
17 #define JOY_RANGE (BTN_DEAD - BTN_JOYSTICK + 1)
18
19 /*
20 * Map buttons manually to extend the default joystick button limit
21 */
universal_pidff_input_mapping(struct hid_device * hdev,struct hid_input * hi,struct hid_field * field,struct hid_usage * usage,unsigned long ** bit,int * max)22 static int universal_pidff_input_mapping(struct hid_device *hdev,
23 struct hid_input *hi, struct hid_field *field, struct hid_usage *usage,
24 unsigned long **bit, int *max)
25 {
26 if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
27 return 0;
28
29 if (field->application != HID_GD_JOYSTICK)
30 return 0;
31
32 int button = ((usage->hid - 1) & HID_USAGE);
33 int code = button + BTN_JOYSTICK;
34
35 /* Detect the end of JOYSTICK buttons range */
36 if (code > BTN_DEAD)
37 code = button + KEY_NEXT_FAVORITE - JOY_RANGE;
38
39 /*
40 * Map overflowing buttons to KEY_RESERVED to not ignore
41 * them and let them still trigger MSC_SCAN
42 */
43 if (code > KEY_MAX)
44 code = KEY_RESERVED;
45
46 hid_map_usage(hi, usage, bit, max, EV_KEY, code);
47 hid_dbg(hdev, "Button %d: usage %d", button, code);
48 return 1;
49 }
50
51 /*
52 * Check if the device is PID and initialize it
53 * Add quirks after initialisation
54 */
universal_pidff_probe(struct hid_device * hdev,const struct hid_device_id * id)55 static int universal_pidff_probe(struct hid_device *hdev,
56 const struct hid_device_id *id)
57 {
58 int i, error;
59 error = hid_parse(hdev);
60 if (error) {
61 hid_err(hdev, "HID parse failed\n");
62 goto err;
63 }
64
65 error = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
66 if (error) {
67 hid_err(hdev, "HID hw start failed\n");
68 goto err;
69 }
70
71 /* Check if device contains PID usage page */
72 error = 1;
73 for (i = 0; i < hdev->collection_size; i++)
74 if ((hdev->collection[i].usage & HID_USAGE_PAGE) == HID_UP_PID) {
75 error = 0;
76 hid_dbg(hdev, "PID usage page found\n");
77 break;
78 }
79
80 /*
81 * Do not fail as this might be the second "device"
82 * just for additional buttons/axes. Exit cleanly if force
83 * feedback usage page wasn't found (included devices were
84 * tested and confirmed to be USB PID after all).
85 */
86 if (error) {
87 hid_dbg(hdev, "PID usage page not found in the descriptor\n");
88 return 0;
89 }
90
91 /* Check if HID_PID support is enabled */
92 int (*init_function)(struct hid_device *, __u32);
93 init_function = hid_pidff_init_with_quirks;
94
95 if (!init_function) {
96 hid_warn(hdev, "HID_PID support not enabled!\n");
97 return 0;
98 }
99
100 error = init_function(hdev, id->driver_data);
101 if (error) {
102 hid_warn(hdev, "Error initialising force feedback\n");
103 goto err;
104 }
105
106 hid_info(hdev, "Universal pidff driver loaded sucesfully!");
107
108 return 0;
109 err:
110 return error;
111 }
112
universal_pidff_input_configured(struct hid_device * hdev,struct hid_input * hidinput)113 static int universal_pidff_input_configured(struct hid_device *hdev,
114 struct hid_input *hidinput)
115 {
116 int axis;
117 struct input_dev *input = hidinput->input;
118
119 if (!input->absinfo)
120 return 0;
121
122 /* Decrease fuzz and deadzone on available axes */
123 for (axis = ABS_X; axis <= ABS_BRAKE; axis++) {
124 if (!test_bit(axis, input->absbit))
125 continue;
126
127 input_set_abs_params(input, axis,
128 input->absinfo[axis].minimum,
129 input->absinfo[axis].maximum,
130 axis == ABS_X ? 0 : 8, 0);
131 }
132
133 /* Remove fuzz and deadzone from the second joystick axis */
134 if (hdev->vendor == USB_VENDOR_ID_FFBEAST &&
135 hdev->product == USB_DEVICE_ID_FFBEAST_JOYSTICK)
136 input_set_abs_params(input, ABS_Y,
137 input->absinfo[ABS_Y].minimum,
138 input->absinfo[ABS_Y].maximum, 0, 0);
139
140 return 0;
141 }
142
143 static const struct hid_device_id universal_pidff_devices[] = {
144 { HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R3),
145 .driver_data = HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION },
146 { HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R3_2),
147 .driver_data = HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION },
148 { HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R5),
149 .driver_data = HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION },
150 { HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R5_2),
151 .driver_data = HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION },
152 { HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R9),
153 .driver_data = HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION },
154 { HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R9_2),
155 .driver_data = HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION },
156 { HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R12),
157 .driver_data = HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION },
158 { HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R12_2),
159 .driver_data = HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION },
160 { HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R16_R21),
161 .driver_data = HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION },
162 { HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R16_R21_2),
163 .driver_data = HID_PIDFF_QUIRK_FIX_WHEEL_DIRECTION },
164 { HID_USB_DEVICE(USB_VENDOR_ID_CAMMUS, USB_DEVICE_ID_CAMMUS_C5) },
165 { HID_USB_DEVICE(USB_VENDOR_ID_CAMMUS, USB_DEVICE_ID_CAMMUS_C12) },
166 { HID_USB_DEVICE(USB_VENDOR_ID_VRS, USB_DEVICE_ID_VRS_DFP),
167 .driver_data = HID_PIDFF_QUIRK_PERMISSIVE_CONTROL },
168 { HID_USB_DEVICE(USB_VENDOR_ID_FFBEAST, USB_DEVICE_ID_FFBEAST_JOYSTICK), },
169 { HID_USB_DEVICE(USB_VENDOR_ID_FFBEAST, USB_DEVICE_ID_FFBEAST_RUDDER), },
170 { HID_USB_DEVICE(USB_VENDOR_ID_FFBEAST, USB_DEVICE_ID_FFBEAST_WHEEL) },
171 { HID_USB_DEVICE(USB_VENDOR_ID_LITE_STAR, USB_DEVICE_ID_PXN_V10),
172 .driver_data = HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY },
173 { HID_USB_DEVICE(USB_VENDOR_ID_LITE_STAR, USB_DEVICE_ID_PXN_V12),
174 .driver_data = HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY },
175 { HID_USB_DEVICE(USB_VENDOR_ID_LITE_STAR, USB_DEVICE_ID_PXN_V12_LITE),
176 .driver_data = HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY },
177 { HID_USB_DEVICE(USB_VENDOR_ID_LITE_STAR, USB_DEVICE_ID_PXN_V12_LITE_2),
178 .driver_data = HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY },
179 { HID_USB_DEVICE(USB_VENDOR_ID_LITE_STAR, USB_DEVICE_LITE_STAR_GT987_FF),
180 .driver_data = HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY },
181 { }
182 };
183 MODULE_DEVICE_TABLE(hid, universal_pidff_devices);
184
185 static struct hid_driver universal_pidff = {
186 .name = "hid-universal-pidff",
187 .id_table = universal_pidff_devices,
188 .input_mapping = universal_pidff_input_mapping,
189 .probe = universal_pidff_probe,
190 .input_configured = universal_pidff_input_configured
191 };
192 module_hid_driver(universal_pidff);
193
194 MODULE_DESCRIPTION("Universal driver for USB PID Force Feedback devices");
195 MODULE_LICENSE("GPL");
196 MODULE_AUTHOR("Makarenko Oleg <oleg@makarenk.ooo>");
197 MODULE_AUTHOR("Tomasz Pakuła <tomasz.pakula.oficjalny@gmail.com>");
198