hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

HID: move thrustmaster FF processing 

Signed-off-by: Jiri Slaby <jirislaby@gmail.com>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
This commit is contained in:
Jiri Slaby 2008-09-18 12:23:31 +02:00 committed by Jiri Kosina
parent 5f022298aa
commit 10e41a711e
10 changed files with 106 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
drivers/hid/Kconfig
View File

@ -243,6 +243,15 @@ config HID_SUNPLUS
---help---
Support for Sunplus WDesktop input device.
config THRUSTMASTER_FF
tristate "ThrustMaster devices support"
default m
depends on USB_HID
select INPUT_FF_MEMLESS
help
Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or
a THRUSTMASTER Ferrari GT Rumble Force or Force Feedback Wheel.
endmenu
endif # HID_SUPPORT

1
drivers/hid/Makefile
View File

@ -37,6 +37,7 @@ obj-$(CONFIG_HID_PETALYNX) += hid-petalynx.o
obj-$(CONFIG_HID_SAMSUNG) += hid-samsung.o
obj-$(CONFIG_HID_SONY) += hid-sony.o
obj-$(CONFIG_HID_SUNPLUS) += hid-sunplus.o
obj-$(CONFIG_THRUSTMASTER_FF) += hid-tmff.o
obj-$(CONFIG_USB_HID) += usbhid/
obj-$(CONFIG_USB_MOUSE) += usbhid/

4
drivers/hid/hid-core.c
View File

@ -1516,6 +1516,10 @@ static const struct hid_device_id hid_ignore_list[] = {
{ HID_USB_DEVICE(USB_VENDOR_ID_SOUNDGRAPH, USB_DEVICE_ID_SOUNDGRAPH_IMON_LCD) },
{ HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY1) },
{ HID_USB_DEVICE(USB_VENDOR_ID_TENX, USB_DEVICE_ID_TENX_IBUDDY2) },
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300) },
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304) },
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651) },
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654) },
{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_LABPRO) },
{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_GOTEMP) },
{ HID_USB_DEVICE(USB_VENDOR_ID_VERNIER, USB_DEVICE_ID_VERNIER_SKIP) },

3
drivers/hid/hid-dummy.c
View File

@ -55,6 +55,9 @@ static int __init hid_dummy_init(void)
#ifdef CONFIG_HID_SUNPLUS_MODULE
HID_COMPAT_CALL_DRIVER(sunplus);
#endif
#ifdef CONFIG_THRUSTMASTER_FF_MODULE
HID_COMPAT_CALL_DRIVER(thrustmaster);
#endif
return -EIO;
}

2
drivers/hid/hid-ids.h
View File

@ -357,6 +357,8 @@
#define USB_DEVICE_ID_TENX_IBUDDY1 0x0001
#define USB_DEVICE_ID_TENX_IBUDDY2 0x0002
#define USB_VENDOR_ID_THRUSTMASTER 0x044f
#define USB_VENDOR_ID_TOPMAX 0x0663
#define USB_DEVICE_ID_TOPMAX_COBRAPAD 0x0103

132
drivers/hid/usbhid/hid-tmff.c → drivers/hid/hid-tmff.c
View File

@ -27,23 +27,17 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <linux/hid.h>
#include <linux/input.h>
#undef DEBUG
#include <linux/usb.h>
#include <linux/hid.h>
#include "usbhid.h"
#include "hid-ids.h"
#include "usbhid/usbhid.h"
/* Usages for thrustmaster devices I know about */
#define THRUSTMASTER_USAGE_FF (HID_UP_GENDESK | 0xbb)
struct dev_type {
u16 idVendor;
u16 idProduct;
const signed short *ff;
};
static const signed short ff_rumble[] = {
FF_RUMBLE,
-1
@ -54,21 +48,13 @@ static const signed short ff_joystick[] = {
-1
};
static const struct dev_type devices[] = {
{ 0x44f, 0xb300, ff_rumble },
{ 0x44f, 0xb304, ff_rumble },
{ 0x44f, 0xb651, ff_rumble }, /* FGT Rumble Force Wheel */
{ 0x44f, 0xb654, ff_joystick }, /* FGT Force Feedback Wheel */
};
struct tmff_device {
struct hid_report *report;
struct hid_field *ff_field;
};
/* Changes values from 0 to 0xffff into values from minimum to maximum */
static inline int hid_tmff_scale_u16(unsigned int in,
int minimum, int maximum)
static inline int tmff_scale_u16(unsigned int in, int minimum, int maximum)
{
int ret;
@ -81,8 +67,7 @@ static inline int hid_tmff_scale_u16(unsigned int in,
}
/* Changes values from -0x80 to 0x7f into values from minimum to maximum */
static inline int hid_tmff_scale_s8(int in,
int minimum, int maximum)
static inline int tmff_scale_s8(int in, int minimum, int maximum)
{
int ret;
@ -94,7 +79,8 @@ static inline int hid_tmff_scale_s8(int in,
return ret;
}
static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *effect)
static int tmff_play(struct input_dev *dev, void *data,
struct ff_effect *effect)
{
struct hid_device *hid = input_get_drvdata(dev);
struct tmff_device *tmff = data;
@ -104,10 +90,10 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
switch (effect->type) {
case FF_CONSTANT:
x = hid_tmff_scale_s8(effect->u.ramp.start_level,
x = tmff_scale_s8(effect->u.ramp.start_level,
ff_field->logical_minimum,
ff_field->logical_maximum);
y = hid_tmff_scale_s8(effect->u.ramp.end_level,
y = tmff_scale_s8(effect->u.ramp.end_level,
ff_field->logical_minimum,
ff_field->logical_maximum);
@ -118,10 +104,10 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
break;
case FF_RUMBLE:
left = hid_tmff_scale_u16(effect->u.rumble.weak_magnitude,
left = tmff_scale_u16(effect->u.rumble.weak_magnitude,
ff_field->logical_minimum,
ff_field->logical_maximum);
right = hid_tmff_scale_u16(effect->u.rumble.strong_magnitude,
right = tmff_scale_u16(effect->u.rumble.strong_magnitude,
ff_field->logical_minimum,
ff_field->logical_maximum);
@ -134,14 +120,14 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
return 0;
}
int hid_tmff_init(struct hid_device *hid)
static int tmff_init(struct hid_device *hid, const signed short *ff_bits)
{
struct tmff_device *tmff;
struct hid_report *report;
struct list_head *report_list;
struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
struct hid_input *hidinput = list_entry(hid->inputs.next,
struct hid_input, list);
struct input_dev *input_dev = hidinput->input;
const signed short *ff_bits = ff_joystick;
int error;
int i;
@ -163,17 +149,22 @@ int hid_tmff_init(struct hid_device *hid)
switch (field->usage[0].hid) {
case THRUSTMASTER_USAGE_FF:
if (field->report_count < 2) {
warn("ignoring FF field with report_count < 2");
warn("ignoring FF field with "
"report_count < 2");
continue;
}
if (field->logical_maximum == field->logical_minimum) {
warn("ignoring FF field with logical_maximum == logical_minimum");
if (field->logical_maximum ==
field->logical_minimum) {
warn("ignoring FF field with "
"logical_maximum == "
"logical_minimum");
continue;
}
if (tmff->report && tmff->report != report) {
warn("ignoring FF field in other report");
warn("ignoring FF field in other "
"report");
continue;
}
@ -185,21 +176,14 @@ int hid_tmff_init(struct hid_device *hid)
tmff->report = report;
tmff->ff_field = field;
for (i = 0; i < ARRAY_SIZE(devices); i++) {
if (input_dev->id.vendor == devices[i].idVendor &&
input_dev->id.product == devices[i].idProduct) {
ff_bits = devices[i].ff;
break;
}
}
for (i = 0; ff_bits[i] >= 0; i++)
set_bit(ff_bits[i], input_dev->ffbit);
break;
default:
warn("ignoring unknown output usage %08x", field->usage[0].hid);
warn("ignoring unknown output usage %08x",
field->usage[0].hid);
continue;
}
}
@ -211,15 +195,73 @@ int hid_tmff_init(struct hid_device *hid)
goto fail;
}
error = input_ff_create_memless(input_dev, tmff, hid_tmff_play);
error = input_ff_create_memless(input_dev, tmff, tmff_play);
if (error)
goto fail;
info("Force feedback for ThrustMaster devices by Zinx Verituse <zinx@epicsol.org>");
info("Force feedback for ThrustMaster devices by Zinx Verituse "
"<zinx@epicsol.org>");
return 0;
fail:
fail:
kfree(tmff);
return error;
}
static int tm_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
int ret;
ret = hid_parse(hdev);
if (ret) {
dev_err(&hdev->dev, "parse failed\n");
goto err;
}
ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
if (ret) {
dev_err(&hdev->dev, "hw start failed\n");
goto err;
}
tmff_init(hdev, (void *)id->driver_data);
return 0;
err:
return ret;
}
static const struct hid_device_id tm_devices[] = {
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb300),
.driver_data = (unsigned long)ff_rumble },
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb304),
.driver_data = (unsigned long)ff_rumble },
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb651), /* FGT Rumble Force Wheel */
.driver_data = (unsigned long)ff_rumble },
{ HID_USB_DEVICE(USB_VENDOR_ID_THRUSTMASTER, 0xb654), /* FGT Force Feedback Wheel */
.driver_data = (unsigned long)ff_joystick },
{ }
};
MODULE_DEVICE_TABLE(hid, tm_devices);
static struct hid_driver tm_driver = {
.name = "thrustmaster",
.id_table = tm_devices,
.probe = tm_probe,
};
static int tm_init(void)
{
return hid_register_driver(&tm_driver);
}
static void tm_exit(void)
{
hid_unregister_driver(&tm_driver);
}
module_init(tm_init);
module_exit(tm_exit);
MODULE_LICENSE("GPL");
HID_COMPAT_LOAD_DRIVER(thrustmaster);

11
drivers/hid/usbhid/Kconfig
View File

@ -44,17 +44,6 @@ config HID_PID
feedback for it. Microsoft Sidewinder Force Feedback 2 is one of such
devices.
config THRUSTMASTER_FF
bool "ThrustMaster devices support"
depends on HID_FF
select INPUT_FF_MEMLESS if USB_HID
help
Say Y here if you have a THRUSTMASTER FireStore Dual Power 2 or
a THRUSTMASTER Ferrari GT Rumble Force or Force Feedback Wheel,
and want to enable force feedback support for it.
Note: if you say N here, this device will still be supported, but without
force feedback.
config ZEROPLUS_FF
bool "Zeroplus based game controller support"
depends on HID_FF

3
drivers/hid/usbhid/Makefile
View File

@ -13,9 +13,6 @@ endif
ifeq ($(CONFIG_HID_PID),y)
usbhid-objs += hid-pidff.o
endif
ifeq ($(CONFIG_THRUSTMASTER_FF),y)
usbhid-objs += hid-tmff.o
endif
ifeq ($(CONFIG_ZEROPLUS_FF),y)
usbhid-objs += hid-zpff.o
endif

6
drivers/hid/usbhid/hid-ff.c
View File

@ -50,12 +50,6 @@ struct hid_ff_initializer {
* be a PID device
*/
static struct hid_ff_initializer inits[] = {
#ifdef CONFIG_THRUSTMASTER_FF
{ 0x44f, 0xb300, hid_tmff_init },
{ 0x44f, 0xb304, hid_tmff_init },
{ 0x44f, 0xb651, hid_tmff_init }, /* FGT Rumble Force Wheel */
{ 0x44f, 0xb654, hid_tmff_init }, /* FGT Force Feedback Wheel */
#endif
#ifdef CONFIG_ZEROPLUS_FF
{ 0xc12, 0x0005, hid_zpff_init },
{ 0xc12, 0x0030, hid_zpff_init },

1
include/linux/hid.h
View File

@ -760,7 +760,6 @@ void usbhid_set_leds(struct hid_device *hid);
#ifdef CONFIG_HID_FF
int hid_ff_init(struct hid_device *hid);
int hid_tmff_init(struct hid_device *hid);
int hid_zpff_init(struct hid_device *hid);
#ifdef CONFIG_HID_PID
int hid_pidff_init(struct hid_device *hid);