projects/linux·blob master · refs

207 lines · 6.9 KiB

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