hid-universal-pidff.c

  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;
108	}
109
110	hid_info(hdev, "Universal pidff driver loaded successfully!");
111
112	return 0;
113err:
114	return error;
115}
116
117static int universal_pidff_input_configured(struct hid_device *hdev,
118					    struct hid_input *hidinput)
119{
120	int axis;
121	struct input_dev *input = hidinput->input;
122
123	if (!input->absinfo)
124		return 0;
125
126	/* Decrease fuzz and deadzone on available axes */
127	for (axis = ABS_X; axis <= ABS_BRAKE; axis++) {
128		if (!test_bit(axis, input->absbit))
129			continue;
130
131		input_set_abs_params(input, axis, input->absinfo[axis].minimum,
132				     input->absinfo[axis].maximum,
133				     axis == ABS_X ? 0 : 8, 0);
134	}
135
136	/* Remove fuzz and deadzone from the second joystick axis */
137	if (hdev->vendor == USB_VENDOR_ID_FFBEAST &&
138	    hdev->product == USB_DEVICE_ID_FFBEAST_JOYSTICK)
139		input_set_abs_params(input, ABS_Y,
140				     input->absinfo[ABS_Y].minimum,
141				     input->absinfo[ABS_Y].maximum, 0, 0);
142
143	return 0;
144}
145
146static const struct hid_device_id universal_pidff_devices[] = {
147	{ HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R3),
148	  .driver_data = HID_PIDFF_QUIRK_FIX_CONDITIONAL_DIRECTION },
149	{ HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R3_2),
150	  .driver_data = HID_PIDFF_QUIRK_FIX_CONDITIONAL_DIRECTION },
151	{ HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R5),
152	  .driver_data = HID_PIDFF_QUIRK_FIX_CONDITIONAL_DIRECTION },
153	{ HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R5_2),
154	  .driver_data = HID_PIDFF_QUIRK_FIX_CONDITIONAL_DIRECTION },
155	{ HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R9),
156	  .driver_data = HID_PIDFF_QUIRK_FIX_CONDITIONAL_DIRECTION },
157	{ HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R9_2),
158	  .driver_data = HID_PIDFF_QUIRK_FIX_CONDITIONAL_DIRECTION },
159	{ HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R12),
160	  .driver_data = HID_PIDFF_QUIRK_FIX_CONDITIONAL_DIRECTION },
161	{ HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R12_2),
162	  .driver_data = HID_PIDFF_QUIRK_FIX_CONDITIONAL_DIRECTION },
163	{ HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R16_R21),
164	  .driver_data = HID_PIDFF_QUIRK_FIX_CONDITIONAL_DIRECTION },
165	{ HID_USB_DEVICE(USB_VENDOR_ID_MOZA, USB_DEVICE_ID_MOZA_R16_R21_2),
166	  .driver_data = HID_PIDFF_QUIRK_FIX_CONDITIONAL_DIRECTION },
167	{ HID_USB_DEVICE(USB_VENDOR_ID_CAMMUS, USB_DEVICE_ID_CAMMUS_C5) },
168	{ HID_USB_DEVICE(USB_VENDOR_ID_CAMMUS, USB_DEVICE_ID_CAMMUS_C12) },
169	{ HID_USB_DEVICE(USB_VENDOR_ID_VRS, USB_DEVICE_ID_VRS_DFP),
170	  .driver_data = HID_PIDFF_QUIRK_PERMISSIVE_CONTROL },
171	{ HID_USB_DEVICE(USB_VENDOR_ID_FFBEAST, USB_DEVICE_ID_FFBEAST_JOYSTICK), },
172	{ HID_USB_DEVICE(USB_VENDOR_ID_FFBEAST, USB_DEVICE_ID_FFBEAST_RUDDER), },
173	{ HID_USB_DEVICE(USB_VENDOR_ID_FFBEAST, USB_DEVICE_ID_FFBEAST_WHEEL) },
174	{ HID_USB_DEVICE(USB_VENDOR_ID_LITE_STAR, USB_DEVICE_ID_PXN_V10),
175	  .driver_data = HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY },
176	{ HID_USB_DEVICE(USB_VENDOR_ID_LITE_STAR, USB_DEVICE_ID_PXN_V12),
177	  .driver_data = HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY },
178	{ HID_USB_DEVICE(USB_VENDOR_ID_LITE_STAR, USB_DEVICE_ID_PXN_V12_LITE),
179	  .driver_data = HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY },
180	{ HID_USB_DEVICE(USB_VENDOR_ID_LITE_STAR, USB_DEVICE_ID_PXN_V12_LITE_2),
181	  .driver_data = HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY },
182	{ HID_USB_DEVICE(USB_VENDOR_ID_LITE_STAR, USB_DEVICE_ID_LITE_STAR_GT987),
183	  .driver_data = HID_PIDFF_QUIRK_PERIODIC_SINE_ONLY },
184	{ HID_USB_DEVICE(USB_VENDOR_ID_ASETEK, USB_DEVICE_ID_ASETEK_INVICTA) },
185	{ HID_USB_DEVICE(USB_VENDOR_ID_ASETEK, USB_DEVICE_ID_ASETEK_FORTE) },
186	{ HID_USB_DEVICE(USB_VENDOR_ID_ASETEK, USB_DEVICE_ID_ASETEK_LA_PRIMA) },
187	{ HID_USB_DEVICE(USB_VENDOR_ID_ASETEK, USB_DEVICE_ID_ASETEK_TONY_KANAAN) },
188	{}
189};
190MODULE_DEVICE_TABLE(hid, universal_pidff_devices);
191
192static struct hid_driver universal_pidff = {
193	.name = "hid-universal-pidff",
194	.id_table = universal_pidff_devices,
195	.input_mapping = universal_pidff_input_mapping,
196	.probe = universal_pidff_probe,
197	.input_configured = universal_pidff_input_configured
198};
199module_hid_driver(universal_pidff);
200
201MODULE_DESCRIPTION("Universal driver for USB PID Force Feedback devices");
202MODULE_LICENSE("GPL");
203MODULE_AUTHOR("Oleg Makarenko <oleg@makarenk.ooo>");
204MODULE_AUTHOR("Tomasz Pakuła <tomasz.pakula.oficjalny@gmail.com>");