2010-09-22 05:19:42 -06:00
/*
2012-04-21 06:41:16 -06:00
* Force feedback support for Logitech Gaming Wheels
2010-09-22 05:19:42 -06:00
*
2012-04-21 06:41:16 -06:00
* Including G27 , G25 , DFP , DFGT , FFEX , Momo , Momo2 &
* Speed Force Wireless ( WiiWheel )
2010-09-22 05:19:42 -06:00
*
* Copyright ( c ) 2010 Simon Wood < simon @ mungewell . org >
*/
/*
* This program is free software ; you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation ; either version 2 of the License , or
* ( at your option ) any later version .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
*
* You should have received a copy of the GNU General Public License
* along with this program ; if not , write to the Free Software
* Foundation , Inc . , 59 Temple Place , Suite 330 , Boston , MA 02111 - 1307 USA
*/
# include <linux/input.h>
# include <linux/usb.h>
# include <linux/hid.h>
# include "usbhid/usbhid.h"
# include "hid-lg.h"
2015-02-18 09:59:22 -07:00
# include "hid-lg4ff.h"
HID: lg4ff - Move handling of Logitech wheels to lg4ff driver
This is the first out of five patches me and Simon Wood (CC'd) have been
working on. It separates the handling of Logite from the generic lgff driver
and adds additional features specific for the Logitech wheels, namely
- Native mode support for Driving Force GT, Driving Force Pro, G25 and G27
wheels Every Logitech wheel reports itself as generic Logitech Driving Force
wheel (VID 046d, PID c294). This is done to ensu wheel will work on every USB
HID-aware system even when no Logitech driver is available. It however limits
the capabilit wheel - range is limited to 200 degrees, G25/G27 don't report the
clutch pedal and there is only one combined axis for t brake. The switch to
native mode is done via hardware-specific command which is different for each
wheel. When the wheel receives such command, it simulates reconnect and reports
to the OS with its actual PID.
- Adjustable wheel range DFGT, DFP, G25 and G27 have variable range of the
steering wheel. The range is limited by applying a maximum constant when the
wheel is turned beyond the allowed range. The limit as also set by a
hardware-specific command. There is a comm command for DFGT, G25 and G27 and
another one for DFP. It is probably possible to use the DFP command to limit
the range other Logitech wheels too, but this is not supported by the official
Logitech driver for Windows. The patch adds a sysfs interface which allows for
the range to be set from userspace.
- Fixed autocentering command All Logitech wheels support FF_AUTOCENTER effect.
The original implementation in the lgff driver didn't work well with patch
fixes it. According to USB communication sniffs the Formula Force EX (pretty
much rebranded original Driving Force accept the generic autocentering command,
this issue is also addressed by the patch
There are still some features this patch doesn't cover, but since some of them
will most likely require modifications of memless driver we have decided not to
include them yet.
As first we decided to move the handling of Logitech wheels from hid-lgff
driver to hid-lg4ff driver (originally used fo At also adds PID of Logitech
Driving Force GT.
Signed-off-by: Michal Malý <madcatxster@gmail.com>
Signed-off-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-08-04 08:16:09 -06:00
# include "hid-ids.h"
2010-09-22 05:19:42 -06:00
2015-02-18 09:59:21 -07:00
# define LG4FF_MMODE_IS_MULTIMODE 0
2015-02-18 09:59:20 -07:00
# define LG4FF_MMODE_SWITCHED 1
# define LG4FF_MMODE_NOT_MULTIMODE 2
2015-02-18 09:59:21 -07:00
# define LG4FF_MODE_NATIVE_IDX 0
# define LG4FF_MODE_DFEX_IDX 1
# define LG4FF_MODE_DFP_IDX 2
# define LG4FF_MODE_G25_IDX 3
# define LG4FF_MODE_DFGT_IDX 4
# define LG4FF_MODE_G27_IDX 5
2015-11-02 07:56:52 -07:00
# define LG4FF_MODE_G29_IDX 6
# define LG4FF_MODE_MAX_IDX 7
2015-02-18 09:59:21 -07:00
# define LG4FF_MODE_NATIVE BIT(LG4FF_MODE_NATIVE_IDX)
# define LG4FF_MODE_DFEX BIT(LG4FF_MODE_DFEX_IDX)
# define LG4FF_MODE_DFP BIT(LG4FF_MODE_DFP_IDX)
# define LG4FF_MODE_G25 BIT(LG4FF_MODE_G25_IDX)
# define LG4FF_MODE_DFGT BIT(LG4FF_MODE_DFGT_IDX)
# define LG4FF_MODE_G27 BIT(LG4FF_MODE_G27_IDX)
2015-11-02 07:56:52 -07:00
# define LG4FF_MODE_G29 BIT(LG4FF_MODE_G29_IDX)
2015-02-18 09:59:21 -07:00
# define LG4FF_DFEX_TAG "DF-EX"
# define LG4FF_DFEX_NAME "Driving Force / Formula EX"
# define LG4FF_DFP_TAG "DFP"
# define LG4FF_DFP_NAME "Driving Force Pro"
# define LG4FF_G25_TAG "G25"
# define LG4FF_G25_NAME "G25 Racing Wheel"
# define LG4FF_G27_TAG "G27"
# define LG4FF_G27_NAME "G27 Racing Wheel"
2015-11-02 07:56:52 -07:00
# define LG4FF_G29_TAG "G29"
# define LG4FF_G29_NAME "G29 Racing Wheel"
2015-02-18 09:59:21 -07:00
# define LG4FF_DFGT_TAG "DFGT"
# define LG4FF_DFGT_NAME "Driving Force GT"
2015-02-18 09:59:20 -07:00
# define LG4FF_FFEX_REV_MAJ 0x21
# define LG4FF_FFEX_REV_MIN 0x00
2015-04-08 14:56:40 -06:00
static void lg4ff_set_range_dfp ( struct hid_device * hid , u16 range ) ;
static void lg4ff_set_range_g25 ( struct hid_device * hid , u16 range ) ;
2011-08-04 08:20:40 -06:00
2015-04-08 14:56:46 -06:00
struct lg4ff_wheel_data {
2015-04-08 14:56:50 -06:00
const u32 product_id ;
2016-09-18 10:55:37 -06:00
u16 combine ;
2015-04-08 14:56:39 -06:00
u16 range ;
2015-04-08 14:56:50 -06:00
const u16 min_range ;
const u16 max_range ;
2012-04-21 06:41:15 -06:00
# ifdef CONFIG_LEDS_CLASS
2015-04-08 14:56:39 -06:00
u8 led_state ;
2012-04-21 06:41:15 -06:00
struct led_classdev * led [ 5 ] ;
# endif
2015-04-08 14:56:50 -06:00
const u32 alternate_modes ;
const char * const real_tag ;
const char * const real_name ;
const u16 real_product_id ;
2015-04-08 14:56:46 -06:00
2011-08-04 08:20:40 -06:00
void ( * set_range ) ( struct hid_device * hid , u16 range ) ;
} ;
2015-04-08 14:56:46 -06:00
struct lg4ff_device_entry {
2015-04-08 14:56:48 -06:00
spinlock_t report_lock ; /* Protect output HID report */
2015-04-08 14:56:49 -06:00
struct hid_report * report ;
2015-04-08 14:56:46 -06:00
struct lg4ff_wheel_data wdata ;
} ;
HID: lg4ff - Move handling of Logitech wheels to lg4ff driver
This is the first out of five patches me and Simon Wood (CC'd) have been
working on. It separates the handling of Logite from the generic lgff driver
and adds additional features specific for the Logitech wheels, namely
- Native mode support for Driving Force GT, Driving Force Pro, G25 and G27
wheels Every Logitech wheel reports itself as generic Logitech Driving Force
wheel (VID 046d, PID c294). This is done to ensu wheel will work on every USB
HID-aware system even when no Logitech driver is available. It however limits
the capabilit wheel - range is limited to 200 degrees, G25/G27 don't report the
clutch pedal and there is only one combined axis for t brake. The switch to
native mode is done via hardware-specific command which is different for each
wheel. When the wheel receives such command, it simulates reconnect and reports
to the OS with its actual PID.
- Adjustable wheel range DFGT, DFP, G25 and G27 have variable range of the
steering wheel. The range is limited by applying a maximum constant when the
wheel is turned beyond the allowed range. The limit as also set by a
hardware-specific command. There is a comm command for DFGT, G25 and G27 and
another one for DFP. It is probably possible to use the DFP command to limit
the range other Logitech wheels too, but this is not supported by the official
Logitech driver for Windows. The patch adds a sysfs interface which allows for
the range to be set from userspace.
- Fixed autocentering command All Logitech wheels support FF_AUTOCENTER effect.
The original implementation in the lgff driver didn't work well with patch
fixes it. According to USB communication sniffs the Formula Force EX (pretty
much rebranded original Driving Force accept the generic autocentering command,
this issue is also addressed by the patch
There are still some features this patch doesn't cover, but since some of them
will most likely require modifications of memless driver we have decided not to
include them yet.
As first we decided to move the handling of Logitech wheels from hid-lgff
driver to hid-lg4ff driver (originally used fo At also adds PID of Logitech
Driving Force GT.
Signed-off-by: Michal Malý <madcatxster@gmail.com>
Signed-off-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-08-04 08:16:09 -06:00
static const signed short lg4ff_wheel_effects [ ] = {
2010-09-22 05:19:42 -06:00
FF_CONSTANT ,
FF_AUTOCENTER ,
- 1
} ;
HID: lg4ff - Move handling of Logitech wheels to lg4ff driver
This is the first out of five patches me and Simon Wood (CC'd) have been
working on. It separates the handling of Logite from the generic lgff driver
and adds additional features specific for the Logitech wheels, namely
- Native mode support for Driving Force GT, Driving Force Pro, G25 and G27
wheels Every Logitech wheel reports itself as generic Logitech Driving Force
wheel (VID 046d, PID c294). This is done to ensu wheel will work on every USB
HID-aware system even when no Logitech driver is available. It however limits
the capabilit wheel - range is limited to 200 degrees, G25/G27 don't report the
clutch pedal and there is only one combined axis for t brake. The switch to
native mode is done via hardware-specific command which is different for each
wheel. When the wheel receives such command, it simulates reconnect and reports
to the OS with its actual PID.
- Adjustable wheel range DFGT, DFP, G25 and G27 have variable range of the
steering wheel. The range is limited by applying a maximum constant when the
wheel is turned beyond the allowed range. The limit as also set by a
hardware-specific command. There is a comm command for DFGT, G25 and G27 and
another one for DFP. It is probably possible to use the DFP command to limit
the range other Logitech wheels too, but this is not supported by the official
Logitech driver for Windows. The patch adds a sysfs interface which allows for
the range to be set from userspace.
- Fixed autocentering command All Logitech wheels support FF_AUTOCENTER effect.
The original implementation in the lgff driver didn't work well with patch
fixes it. According to USB communication sniffs the Formula Force EX (pretty
much rebranded original Driving Force accept the generic autocentering command,
this issue is also addressed by the patch
There are still some features this patch doesn't cover, but since some of them
will most likely require modifications of memless driver we have decided not to
include them yet.
As first we decided to move the handling of Logitech wheels from hid-lgff
driver to hid-lg4ff driver (originally used fo At also adds PID of Logitech
Driving Force GT.
Signed-off-by: Michal Malý <madcatxster@gmail.com>
Signed-off-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-08-04 08:16:09 -06:00
struct lg4ff_wheel {
2015-04-08 14:56:39 -06:00
const u32 product_id ;
HID: lg4ff - Move handling of Logitech wheels to lg4ff driver
This is the first out of five patches me and Simon Wood (CC'd) have been
working on. It separates the handling of Logite from the generic lgff driver
and adds additional features specific for the Logitech wheels, namely
- Native mode support for Driving Force GT, Driving Force Pro, G25 and G27
wheels Every Logitech wheel reports itself as generic Logitech Driving Force
wheel (VID 046d, PID c294). This is done to ensu wheel will work on every USB
HID-aware system even when no Logitech driver is available. It however limits
the capabilit wheel - range is limited to 200 degrees, G25/G27 don't report the
clutch pedal and there is only one combined axis for t brake. The switch to
native mode is done via hardware-specific command which is different for each
wheel. When the wheel receives such command, it simulates reconnect and reports
to the OS with its actual PID.
- Adjustable wheel range DFGT, DFP, G25 and G27 have variable range of the
steering wheel. The range is limited by applying a maximum constant when the
wheel is turned beyond the allowed range. The limit as also set by a
hardware-specific command. There is a comm command for DFGT, G25 and G27 and
another one for DFP. It is probably possible to use the DFP command to limit
the range other Logitech wheels too, but this is not supported by the official
Logitech driver for Windows. The patch adds a sysfs interface which allows for
the range to be set from userspace.
- Fixed autocentering command All Logitech wheels support FF_AUTOCENTER effect.
The original implementation in the lgff driver didn't work well with patch
fixes it. According to USB communication sniffs the Formula Force EX (pretty
much rebranded original Driving Force accept the generic autocentering command,
this issue is also addressed by the patch
There are still some features this patch doesn't cover, but since some of them
will most likely require modifications of memless driver we have decided not to
include them yet.
As first we decided to move the handling of Logitech wheels from hid-lgff
driver to hid-lg4ff driver (originally used fo At also adds PID of Logitech
Driving Force GT.
Signed-off-by: Michal Malý <madcatxster@gmail.com>
Signed-off-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-08-04 08:16:09 -06:00
const signed short * ff_effects ;
2015-04-08 14:56:39 -06:00
const u16 min_range ;
const u16 max_range ;
2011-08-04 08:20:40 -06:00
void ( * set_range ) ( struct hid_device * hid , u16 range ) ;
HID: lg4ff - Move handling of Logitech wheels to lg4ff driver
This is the first out of five patches me and Simon Wood (CC'd) have been
working on. It separates the handling of Logite from the generic lgff driver
and adds additional features specific for the Logitech wheels, namely
- Native mode support for Driving Force GT, Driving Force Pro, G25 and G27
wheels Every Logitech wheel reports itself as generic Logitech Driving Force
wheel (VID 046d, PID c294). This is done to ensu wheel will work on every USB
HID-aware system even when no Logitech driver is available. It however limits
the capabilit wheel - range is limited to 200 degrees, G25/G27 don't report the
clutch pedal and there is only one combined axis for t brake. The switch to
native mode is done via hardware-specific command which is different for each
wheel. When the wheel receives such command, it simulates reconnect and reports
to the OS with its actual PID.
- Adjustable wheel range DFGT, DFP, G25 and G27 have variable range of the
steering wheel. The range is limited by applying a maximum constant when the
wheel is turned beyond the allowed range. The limit as also set by a
hardware-specific command. There is a comm command for DFGT, G25 and G27 and
another one for DFP. It is probably possible to use the DFP command to limit
the range other Logitech wheels too, but this is not supported by the official
Logitech driver for Windows. The patch adds a sysfs interface which allows for
the range to be set from userspace.
- Fixed autocentering command All Logitech wheels support FF_AUTOCENTER effect.
The original implementation in the lgff driver didn't work well with patch
fixes it. According to USB communication sniffs the Formula Force EX (pretty
much rebranded original Driving Force accept the generic autocentering command,
this issue is also addressed by the patch
There are still some features this patch doesn't cover, but since some of them
will most likely require modifications of memless driver we have decided not to
include them yet.
As first we decided to move the handling of Logitech wheels from hid-lgff
driver to hid-lg4ff driver (originally used fo At also adds PID of Logitech
Driving Force GT.
Signed-off-by: Michal Malý <madcatxster@gmail.com>
Signed-off-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-08-04 08:16:09 -06:00
} ;
2015-02-18 09:59:20 -07:00
struct lg4ff_compat_mode_switch {
2015-04-08 14:56:39 -06:00
const u8 cmd_count ; /* Number of commands to send */
const u8 cmd [ ] ;
2015-02-18 09:59:20 -07:00
} ;
struct lg4ff_wheel_ident_info {
2015-11-02 07:56:51 -07:00
const u32 modes ;
2015-02-18 09:59:20 -07:00
const u16 mask ;
const u16 result ;
const u16 real_product_id ;
} ;
2015-02-18 09:59:21 -07:00
struct lg4ff_multimode_wheel {
const u16 product_id ;
const u32 alternate_modes ;
const char * real_tag ;
const char * real_name ;
} ;
struct lg4ff_alternate_mode {
const u16 product_id ;
const char * tag ;
const char * name ;
} ;
HID: lg4ff - Move handling of Logitech wheels to lg4ff driver
This is the first out of five patches me and Simon Wood (CC'd) have been
working on. It separates the handling of Logite from the generic lgff driver
and adds additional features specific for the Logitech wheels, namely
- Native mode support for Driving Force GT, Driving Force Pro, G25 and G27
wheels Every Logitech wheel reports itself as generic Logitech Driving Force
wheel (VID 046d, PID c294). This is done to ensu wheel will work on every USB
HID-aware system even when no Logitech driver is available. It however limits
the capabilit wheel - range is limited to 200 degrees, G25/G27 don't report the
clutch pedal and there is only one combined axis for t brake. The switch to
native mode is done via hardware-specific command which is different for each
wheel. When the wheel receives such command, it simulates reconnect and reports
to the OS with its actual PID.
- Adjustable wheel range DFGT, DFP, G25 and G27 have variable range of the
steering wheel. The range is limited by applying a maximum constant when the
wheel is turned beyond the allowed range. The limit as also set by a
hardware-specific command. There is a comm command for DFGT, G25 and G27 and
another one for DFP. It is probably possible to use the DFP command to limit
the range other Logitech wheels too, but this is not supported by the official
Logitech driver for Windows. The patch adds a sysfs interface which allows for
the range to be set from userspace.
- Fixed autocentering command All Logitech wheels support FF_AUTOCENTER effect.
The original implementation in the lgff driver didn't work well with patch
fixes it. According to USB communication sniffs the Formula Force EX (pretty
much rebranded original Driving Force accept the generic autocentering command,
this issue is also addressed by the patch
There are still some features this patch doesn't cover, but since some of them
will most likely require modifications of memless driver we have decided not to
include them yet.
As first we decided to move the handling of Logitech wheels from hid-lgff
driver to hid-lg4ff driver (originally used fo At also adds PID of Logitech
Driving Force GT.
Signed-off-by: Michal Malý <madcatxster@gmail.com>
Signed-off-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-08-04 08:16:09 -06:00
static const struct lg4ff_wheel lg4ff_devices [ ] = {
2016-09-18 10:55:41 -06:00
{ USB_DEVICE_ID_LOGITECH_WINGMAN_FFG , lg4ff_wheel_effects , 40 , 180 , NULL } ,
2011-08-04 08:20:40 -06:00
{ USB_DEVICE_ID_LOGITECH_WHEEL , lg4ff_wheel_effects , 40 , 270 , NULL } ,
{ USB_DEVICE_ID_LOGITECH_MOMO_WHEEL , lg4ff_wheel_effects , 40 , 270 , NULL } ,
2015-04-08 14:56:40 -06:00
{ USB_DEVICE_ID_LOGITECH_DFP_WHEEL , lg4ff_wheel_effects , 40 , 900 , lg4ff_set_range_dfp } ,
{ USB_DEVICE_ID_LOGITECH_G25_WHEEL , lg4ff_wheel_effects , 40 , 900 , lg4ff_set_range_g25 } ,
{ USB_DEVICE_ID_LOGITECH_DFGT_WHEEL , lg4ff_wheel_effects , 40 , 900 , lg4ff_set_range_g25 } ,
{ USB_DEVICE_ID_LOGITECH_G27_WHEEL , lg4ff_wheel_effects , 40 , 900 , lg4ff_set_range_g25 } ,
2015-11-02 07:56:52 -07:00
{ USB_DEVICE_ID_LOGITECH_G29_WHEEL , lg4ff_wheel_effects , 40 , 900 , lg4ff_set_range_g25 } ,
2011-08-04 08:20:40 -06:00
{ USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2 , lg4ff_wheel_effects , 40 , 270 , NULL } ,
{ USB_DEVICE_ID_LOGITECH_WII_WHEEL , lg4ff_wheel_effects , 40 , 270 , NULL }
HID: lg4ff - Move handling of Logitech wheels to lg4ff driver
This is the first out of five patches me and Simon Wood (CC'd) have been
working on. It separates the handling of Logite from the generic lgff driver
and adds additional features specific for the Logitech wheels, namely
- Native mode support for Driving Force GT, Driving Force Pro, G25 and G27
wheels Every Logitech wheel reports itself as generic Logitech Driving Force
wheel (VID 046d, PID c294). This is done to ensu wheel will work on every USB
HID-aware system even when no Logitech driver is available. It however limits
the capabilit wheel - range is limited to 200 degrees, G25/G27 don't report the
clutch pedal and there is only one combined axis for t brake. The switch to
native mode is done via hardware-specific command which is different for each
wheel. When the wheel receives such command, it simulates reconnect and reports
to the OS with its actual PID.
- Adjustable wheel range DFGT, DFP, G25 and G27 have variable range of the
steering wheel. The range is limited by applying a maximum constant when the
wheel is turned beyond the allowed range. The limit as also set by a
hardware-specific command. There is a comm command for DFGT, G25 and G27 and
another one for DFP. It is probably possible to use the DFP command to limit
the range other Logitech wheels too, but this is not supported by the official
Logitech driver for Windows. The patch adds a sysfs interface which allows for
the range to be set from userspace.
- Fixed autocentering command All Logitech wheels support FF_AUTOCENTER effect.
The original implementation in the lgff driver didn't work well with patch
fixes it. According to USB communication sniffs the Formula Force EX (pretty
much rebranded original Driving Force accept the generic autocentering command,
this issue is also addressed by the patch
There are still some features this patch doesn't cover, but since some of them
will most likely require modifications of memless driver we have decided not to
include them yet.
As first we decided to move the handling of Logitech wheels from hid-lgff
driver to hid-lg4ff driver (originally used fo At also adds PID of Logitech
Driving Force GT.
Signed-off-by: Michal Malý <madcatxster@gmail.com>
Signed-off-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-08-04 08:16:09 -06:00
} ;
2015-02-18 09:59:21 -07:00
static const struct lg4ff_multimode_wheel lg4ff_multimode_wheels [ ] = {
{ USB_DEVICE_ID_LOGITECH_DFP_WHEEL ,
LG4FF_MODE_NATIVE | LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
LG4FF_DFP_TAG , LG4FF_DFP_NAME } ,
{ USB_DEVICE_ID_LOGITECH_G25_WHEEL ,
LG4FF_MODE_NATIVE | LG4FF_MODE_G25 | LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
LG4FF_G25_TAG , LG4FF_G25_NAME } ,
{ USB_DEVICE_ID_LOGITECH_DFGT_WHEEL ,
LG4FF_MODE_NATIVE | LG4FF_MODE_DFGT | LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
LG4FF_DFGT_TAG , LG4FF_DFGT_NAME } ,
{ USB_DEVICE_ID_LOGITECH_G27_WHEEL ,
LG4FF_MODE_NATIVE | LG4FF_MODE_G27 | LG4FF_MODE_G25 | LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
LG4FF_G27_TAG , LG4FF_G27_NAME } ,
2015-11-02 07:56:52 -07:00
{ USB_DEVICE_ID_LOGITECH_G29_WHEEL ,
LG4FF_MODE_NATIVE | LG4FF_MODE_G29 | LG4FF_MODE_G27 | LG4FF_MODE_G25 | LG4FF_MODE_DFGT | LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
LG4FF_G29_TAG , LG4FF_G29_NAME } ,
2015-02-18 09:59:21 -07:00
} ;
static const struct lg4ff_alternate_mode lg4ff_alternate_modes [ ] = {
[ LG4FF_MODE_NATIVE_IDX ] = { 0 , " native " , " " } ,
[ LG4FF_MODE_DFEX_IDX ] = { USB_DEVICE_ID_LOGITECH_WHEEL , LG4FF_DFEX_TAG , LG4FF_DFEX_NAME } ,
[ LG4FF_MODE_DFP_IDX ] = { USB_DEVICE_ID_LOGITECH_DFP_WHEEL , LG4FF_DFP_TAG , LG4FF_DFP_NAME } ,
[ LG4FF_MODE_G25_IDX ] = { USB_DEVICE_ID_LOGITECH_G25_WHEEL , LG4FF_G25_TAG , LG4FF_G25_NAME } ,
[ LG4FF_MODE_DFGT_IDX ] = { USB_DEVICE_ID_LOGITECH_DFGT_WHEEL , LG4FF_DFGT_TAG , LG4FF_DFGT_NAME } ,
2015-11-02 07:56:52 -07:00
[ LG4FF_MODE_G27_IDX ] = { USB_DEVICE_ID_LOGITECH_G27_WHEEL , LG4FF_G27_TAG , LG4FF_G27_NAME } ,
[ LG4FF_MODE_G29_IDX ] = { USB_DEVICE_ID_LOGITECH_G29_WHEEL , LG4FF_G29_TAG , LG4FF_G29_NAME } ,
2015-02-18 09:59:21 -07:00
} ;
2015-02-18 09:59:20 -07:00
/* Multimode wheel identificators */
static const struct lg4ff_wheel_ident_info lg4ff_dfp_ident_info = {
2015-11-02 07:56:51 -07:00
LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
2015-02-18 09:59:20 -07:00
0xf000 ,
0x1000 ,
USB_DEVICE_ID_LOGITECH_DFP_WHEEL
} ;
static const struct lg4ff_wheel_ident_info lg4ff_g25_ident_info = {
2015-11-02 07:56:51 -07:00
LG4FF_MODE_G25 | LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
2015-02-18 09:59:20 -07:00
0xff00 ,
0x1200 ,
USB_DEVICE_ID_LOGITECH_G25_WHEEL
} ;
static const struct lg4ff_wheel_ident_info lg4ff_g27_ident_info = {
2015-11-02 07:56:51 -07:00
LG4FF_MODE_G27 | LG4FF_MODE_G25 | LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
2015-02-18 09:59:20 -07:00
0xfff0 ,
0x1230 ,
USB_DEVICE_ID_LOGITECH_G27_WHEEL
2011-08-04 08:18:11 -06:00
} ;
2015-02-18 09:59:20 -07:00
static const struct lg4ff_wheel_ident_info lg4ff_dfgt_ident_info = {
2015-11-02 07:56:51 -07:00
LG4FF_MODE_DFGT | LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
2015-02-18 09:59:20 -07:00
0xff00 ,
0x1300 ,
USB_DEVICE_ID_LOGITECH_DFGT_WHEEL
2011-08-04 08:18:11 -06:00
} ;
2015-11-02 07:56:52 -07:00
static const struct lg4ff_wheel_ident_info lg4ff_g29_ident_info = {
LG4FF_MODE_G29 | LG4FF_MODE_G27 | LG4FF_MODE_G25 | LG4FF_MODE_DFGT | LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
0xfff8 ,
0x1350 ,
USB_DEVICE_ID_LOGITECH_G29_WHEEL
} ;
static const struct lg4ff_wheel_ident_info lg4ff_g29_ident_info2 = {
LG4FF_MODE_G29 | LG4FF_MODE_G27 | LG4FF_MODE_G25 | LG4FF_MODE_DFGT | LG4FF_MODE_DFP | LG4FF_MODE_DFEX ,
0xff00 ,
0x8900 ,
USB_DEVICE_ID_LOGITECH_G29_WHEEL
} ;
2015-02-18 09:59:20 -07:00
/* Multimode wheel identification checklists */
2015-11-02 07:56:51 -07:00
static const struct lg4ff_wheel_ident_info * lg4ff_main_checklist [ ] = {
2015-11-02 07:56:52 -07:00
& lg4ff_g29_ident_info ,
& lg4ff_g29_ident_info2 ,
2015-11-02 07:56:51 -07:00
& lg4ff_dfgt_ident_info ,
& lg4ff_g27_ident_info ,
& lg4ff_g25_ident_info ,
& lg4ff_dfp_ident_info
2015-02-18 09:59:20 -07:00
} ;
/* Compatibility mode switching commands */
2015-02-18 09:59:23 -07:00
/* EXT_CMD9 - Understood by G27 and DFGT */
static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_dfex = {
2 ,
{ 0xf8 , 0x0a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , /* Revert mode upon USB reset */
0xf8 , 0x09 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 } /* Switch mode to DF-EX with detach */
2011-08-04 08:18:11 -06:00
} ;
2015-02-18 09:59:23 -07:00
static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_dfp = {
2011-08-04 08:18:11 -06:00
2 ,
2015-02-18 09:59:23 -07:00
{ 0xf8 , 0x0a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , /* Revert mode upon USB reset */
0xf8 , 0x09 , 0x01 , 0x01 , 0x00 , 0x00 , 0x00 } /* Switch mode to DFP with detach */
2011-08-04 08:18:11 -06:00
} ;
2015-02-18 09:59:23 -07:00
static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_g25 = {
2 ,
{ 0xf8 , 0x0a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , /* Revert mode upon USB reset */
0xf8 , 0x09 , 0x02 , 0x01 , 0x00 , 0x00 , 0x00 } /* Switch mode to G25 with detach */
2011-08-04 08:18:11 -06:00
} ;
2015-02-18 09:59:23 -07:00
static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_dfgt = {
2011-08-04 08:18:11 -06:00
2 ,
2015-02-18 09:59:23 -07:00
{ 0xf8 , 0x0a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , /* Revert mode upon USB reset */
0xf8 , 0x09 , 0x03 , 0x01 , 0x00 , 0x00 , 0x00 } /* Switch mode to DFGT with detach */
} ;
static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_g27 = {
2 ,
{ 0xf8 , 0x0a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , /* Revert mode upon USB reset */
0xf8 , 0x09 , 0x04 , 0x01 , 0x00 , 0x00 , 0x00 } /* Switch mode to G27 with detach */
} ;
2015-11-02 07:56:52 -07:00
static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext09_g29 = {
2 ,
{ 0xf8 , 0x0a , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , /* Revert mode upon USB reset */
0xf8 , 0x09 , 0x05 , 0x01 , 0x01 , 0x00 , 0x00 } /* Switch mode to G29 with detach */
} ;
2015-02-18 09:59:23 -07:00
/* EXT_CMD1 - Understood by DFP, G25, G27 and DFGT */
static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext01_dfp = {
1 ,
{ 0xf8 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 }
} ;
/* EXT_CMD16 - Understood by G25 and G27 */
static const struct lg4ff_compat_mode_switch lg4ff_mode_switch_ext16_g25 = {
1 ,
{ 0xf8 , 0x10 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 }
2011-08-04 08:18:11 -06:00
} ;
2012-09-23 14:41:08 -06:00
/* Recalculates X axis value accordingly to currently selected range */
2015-04-08 14:56:39 -06:00
static s32 lg4ff_adjust_dfp_x_axis ( s32 value , u16 range )
2012-09-23 14:41:08 -06:00
{
2015-04-08 14:56:39 -06:00
u16 max_range ;
s32 new_value ;
2012-09-23 14:41:08 -06:00
if ( range = = 900 )
return value ;
else if ( range = = 200 )
return value ;
else if ( range < 200 )
max_range = 200 ;
else
max_range = 900 ;
new_value = 8192 + mult_frac ( value - 8192 , max_range , range ) ;
if ( new_value < 0 )
return 0 ;
else if ( new_value > 16383 )
return 16383 ;
else
return new_value ;
}
int lg4ff_adjust_input_event ( struct hid_device * hid , struct hid_field * field ,
2015-04-08 14:56:39 -06:00
struct hid_usage * usage , s32 value , struct lg_drv_data * drv_data )
2012-09-23 14:41:08 -06:00
{
struct lg4ff_device_entry * entry = drv_data - > device_props ;
2015-04-08 14:56:39 -06:00
s32 new_value = 0 ;
2012-09-23 14:41:08 -06:00
if ( ! entry ) {
hid_err ( hid , " Device properties not found " ) ;
return 0 ;
}
2015-04-08 14:56:46 -06:00
switch ( entry - > wdata . product_id ) {
2012-09-23 14:41:08 -06:00
case USB_DEVICE_ID_LOGITECH_DFP_WHEEL :
switch ( usage - > code ) {
case ABS_X :
2015-04-08 14:56:46 -06:00
new_value = lg4ff_adjust_dfp_x_axis ( value , entry - > wdata . range ) ;
2012-09-23 14:41:08 -06:00
input_event ( field - > hidinput - > input , usage - > type , usage - > code , new_value ) ;
return 1 ;
default :
return 0 ;
}
default :
return 0 ;
}
}
2016-09-18 10:55:38 -06:00
int lg4ff_raw_event ( struct hid_device * hdev , struct hid_report * report ,
u8 * rd , int size , struct lg_drv_data * drv_data )
{
2016-09-18 10:55:39 -06:00
int offset ;
2016-09-18 10:55:38 -06:00
struct lg4ff_device_entry * entry = drv_data - > device_props ;
if ( ! entry )
return 0 ;
/* adjust HID report present combined pedals data */
if ( entry - > wdata . combine ) {
switch ( entry - > wdata . product_id ) {
case USB_DEVICE_ID_LOGITECH_WHEEL :
rd [ 5 ] = rd [ 3 ] ;
rd [ 6 ] = 0x7F ;
return 1 ;
2016-09-18 10:55:41 -06:00
case USB_DEVICE_ID_LOGITECH_WINGMAN_FFG :
2016-09-18 10:55:38 -06:00
case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL :
case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2 :
rd [ 4 ] = rd [ 3 ] ;
rd [ 5 ] = 0x7F ;
return 1 ;
case USB_DEVICE_ID_LOGITECH_DFP_WHEEL :
rd [ 5 ] = rd [ 4 ] ;
rd [ 6 ] = 0x7F ;
return 1 ;
2016-09-18 10:55:39 -06:00
case USB_DEVICE_ID_LOGITECH_G25_WHEEL :
case USB_DEVICE_ID_LOGITECH_G27_WHEEL :
offset = 5 ;
break ;
case USB_DEVICE_ID_LOGITECH_DFGT_WHEEL :
case USB_DEVICE_ID_LOGITECH_G29_WHEEL :
offset = 6 ;
break ;
case USB_DEVICE_ID_LOGITECH_WII_WHEEL :
offset = 3 ;
break ;
2016-09-18 10:55:38 -06:00
default :
return 0 ;
}
2016-09-18 10:55:39 -06:00
/* Compute a combined axis when wheel does not supply it */
rd [ offset ] = ( 0xFF + rd [ offset ] - rd [ offset + 1 ] ) > > 1 ;
rd [ offset + 1 ] = 0x7F ;
return 1 ;
2016-09-18 10:55:38 -06:00
}
return 0 ;
}
2015-04-08 14:56:50 -06:00
static void lg4ff_init_wheel_data ( struct lg4ff_wheel_data * const wdata , const struct lg4ff_wheel * wheel ,
const struct lg4ff_multimode_wheel * mmode_wheel ,
const u16 real_product_id )
{
u32 alternate_modes = 0 ;
const char * real_tag = NULL ;
const char * real_name = NULL ;
if ( mmode_wheel ) {
alternate_modes = mmode_wheel - > alternate_modes ;
real_tag = mmode_wheel - > real_tag ;
real_name = mmode_wheel - > real_name ;
}
{
struct lg4ff_wheel_data t_wdata = { . product_id = wheel - > product_id ,
. real_product_id = real_product_id ,
2016-09-18 10:55:37 -06:00
. combine = 0 ,
2015-04-08 14:56:50 -06:00
. min_range = wheel - > min_range ,
. max_range = wheel - > max_range ,
. set_range = wheel - > set_range ,
. alternate_modes = alternate_modes ,
. real_tag = real_tag ,
. real_name = real_name } ;
memcpy ( wdata , & t_wdata , sizeof ( t_wdata ) ) ;
}
}
2015-04-08 14:56:40 -06:00
static int lg4ff_play ( struct input_dev * dev , void * data , struct ff_effect * effect )
2010-09-22 05:19:42 -06:00
{
struct hid_device * hid = input_get_drvdata ( dev ) ;
2015-04-08 14:56:48 -06:00
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
unsigned long flags ;
2015-04-08 14:56:49 -06:00
s32 * value ;
2010-09-22 05:19:42 -06:00
int x ;
2015-04-08 14:56:48 -06:00
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return - EINVAL ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return - EINVAL ;
}
2015-04-08 14:56:49 -06:00
value = entry - > report - > field [ 0 ] - > value ;
2015-04-08 14:56:48 -06:00
2012-09-23 17:13:17 -06:00
# define CLAMP(x) do { if (x < 0) x = 0; else if (x > 0xff) x = 0xff; } while (0)
2010-09-22 05:19:42 -06:00
switch ( effect - > type ) {
case FF_CONSTANT :
x = effect - > u . ramp . start_level + 0x80 ; /* 0x80 is no force */
CLAMP ( x ) ;
2013-11-06 12:30:42 -07:00
2015-04-08 14:56:48 -06:00
spin_lock_irqsave ( & entry - > report_lock , flags ) ;
2013-11-06 12:30:42 -07:00
if ( x = = 0x80 ) {
/* De-activate force in slot-1*/
value [ 0 ] = 0x13 ;
value [ 1 ] = 0x00 ;
value [ 2 ] = 0x00 ;
value [ 3 ] = 0x00 ;
value [ 4 ] = 0x00 ;
value [ 5 ] = 0x00 ;
value [ 6 ] = 0x00 ;
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2015-04-08 14:56:48 -06:00
spin_unlock_irqrestore ( & entry - > report_lock , flags ) ;
2013-11-06 12:30:42 -07:00
return 0 ;
}
2012-09-23 17:09:30 -06:00
value [ 0 ] = 0x11 ; /* Slot 1 */
value [ 1 ] = 0x08 ;
value [ 2 ] = x ;
value [ 3 ] = 0x80 ;
value [ 4 ] = 0x00 ;
value [ 5 ] = 0x00 ;
value [ 6 ] = 0x00 ;
2010-09-22 05:19:42 -06:00
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2015-04-08 14:56:48 -06:00
spin_unlock_irqrestore ( & entry - > report_lock , flags ) ;
2010-09-22 05:19:42 -06:00
break ;
}
return 0 ;
}
2011-08-04 08:22:07 -06:00
/* Sends default autocentering command compatible with
* all wheels except Formula Force EX */
2015-04-08 14:56:40 -06:00
static void lg4ff_set_autocenter_default ( struct input_dev * dev , u16 magnitude )
2010-09-22 05:19:42 -06:00
{
struct hid_device * hid = input_get_drvdata ( dev ) ;
2017-10-17 08:31:51 -06:00
s32 * value ;
2015-04-08 14:56:39 -06:00
u32 expand_a , expand_b ;
2013-11-06 12:30:44 -07:00
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
2015-04-08 14:56:48 -06:00
unsigned long flags ;
2013-11-06 12:30:44 -07:00
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return ;
}
2015-04-08 14:56:49 -06:00
value = entry - > report - > field [ 0 ] - > value ;
2013-11-06 12:30:40 -07:00
2013-11-06 12:30:41 -07:00
/* De-activate Auto-Center */
2015-04-08 14:56:48 -06:00
spin_lock_irqsave ( & entry - > report_lock , flags ) ;
2013-11-06 12:30:41 -07:00
if ( magnitude = = 0 ) {
value [ 0 ] = 0xf5 ;
value [ 1 ] = 0x00 ;
value [ 2 ] = 0x00 ;
value [ 3 ] = 0x00 ;
value [ 4 ] = 0x00 ;
value [ 5 ] = 0x00 ;
value [ 6 ] = 0x00 ;
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2015-04-08 14:56:48 -06:00
spin_unlock_irqrestore ( & entry - > report_lock , flags ) ;
2013-11-06 12:30:41 -07:00
return ;
}
2013-11-06 12:30:40 -07:00
if ( magnitude < = 0xaaaa ) {
expand_a = 0x0c * magnitude ;
expand_b = 0x80 * magnitude ;
} else {
expand_a = ( 0x0c * 0xaaaa ) + 0x06 * ( magnitude - 0xaaaa ) ;
expand_b = ( 0x80 * 0xaaaa ) + 0xff * ( magnitude - 0xaaaa ) ;
}
2010-09-22 05:19:42 -06:00
2013-11-06 12:30:44 -07:00
/* Adjust for non-MOMO wheels */
2015-04-08 14:56:46 -06:00
switch ( entry - > wdata . product_id ) {
2013-11-06 12:30:44 -07:00
case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL :
case USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2 :
break ;
default :
expand_a = expand_a > > 1 ;
break ;
}
2012-09-23 17:09:30 -06:00
value [ 0 ] = 0xfe ;
value [ 1 ] = 0x0d ;
2013-11-06 12:30:40 -07:00
value [ 2 ] = expand_a / 0xaaaa ;
value [ 3 ] = expand_a / 0xaaaa ;
value [ 4 ] = expand_b / 0xaaaa ;
2012-09-23 17:09:30 -06:00
value [ 5 ] = 0x00 ;
value [ 6 ] = 0x00 ;
2010-09-22 05:19:42 -06:00
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2013-11-06 12:30:41 -07:00
/* Activate Auto-Center */
value [ 0 ] = 0x14 ;
value [ 1 ] = 0x00 ;
value [ 2 ] = 0x00 ;
value [ 3 ] = 0x00 ;
value [ 4 ] = 0x00 ;
value [ 5 ] = 0x00 ;
value [ 6 ] = 0x00 ;
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2015-04-08 14:56:48 -06:00
spin_unlock_irqrestore ( & entry - > report_lock , flags ) ;
2010-09-22 05:19:42 -06:00
}
2011-08-04 08:22:07 -06:00
/* Sends autocentering command compatible with Formula Force EX */
2015-04-08 14:56:40 -06:00
static void lg4ff_set_autocenter_ffex ( struct input_dev * dev , u16 magnitude )
2011-08-04 08:22:07 -06:00
{
struct hid_device * hid = input_get_drvdata ( dev ) ;
2015-04-08 14:56:48 -06:00
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
unsigned long flags ;
2015-04-08 14:56:49 -06:00
s32 * value ;
2011-08-04 08:22:07 -06:00
magnitude = magnitude * 90 / 65535 ;
2015-04-08 14:56:48 -06:00
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return ;
}
2015-04-08 14:56:49 -06:00
value = entry - > report - > field [ 0 ] - > value ;
2015-04-08 14:56:48 -06:00
spin_lock_irqsave ( & entry - > report_lock , flags ) ;
2012-09-23 17:09:30 -06:00
value [ 0 ] = 0xfe ;
value [ 1 ] = 0x03 ;
value [ 2 ] = magnitude > > 14 ;
value [ 3 ] = magnitude > > 14 ;
value [ 4 ] = magnitude ;
value [ 5 ] = 0x00 ;
value [ 6 ] = 0x00 ;
2011-08-04 08:22:07 -06:00
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2015-04-08 14:56:48 -06:00
spin_unlock_irqrestore ( & entry - > report_lock , flags ) ;
2011-08-04 08:22:07 -06:00
}
2011-08-04 08:20:40 -06:00
/* Sends command to set range compatible with G25/G27/Driving Force GT */
2015-04-08 14:56:40 -06:00
static void lg4ff_set_range_g25 ( struct hid_device * hid , u16 range )
2011-08-04 08:20:40 -06:00
{
2015-04-08 14:56:48 -06:00
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
unsigned long flags ;
2015-04-08 14:56:49 -06:00
s32 * value ;
2012-09-23 17:09:30 -06:00
2015-04-08 14:56:48 -06:00
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return ;
}
2015-04-08 14:56:49 -06:00
value = entry - > report - > field [ 0 ] - > value ;
2011-08-04 08:20:40 -06:00
dbg_hid ( " G25/G27/DFGT: setting range to %u \n " , range ) ;
2015-04-08 14:56:48 -06:00
spin_lock_irqsave ( & entry - > report_lock , flags ) ;
2012-09-23 17:09:30 -06:00
value [ 0 ] = 0xf8 ;
value [ 1 ] = 0x81 ;
value [ 2 ] = range & 0x00ff ;
value [ 3 ] = ( range & 0xff00 ) > > 8 ;
value [ 4 ] = 0x00 ;
value [ 5 ] = 0x00 ;
value [ 6 ] = 0x00 ;
2011-08-04 08:20:40 -06:00
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2015-04-08 14:56:48 -06:00
spin_unlock_irqrestore ( & entry - > report_lock , flags ) ;
2011-08-04 08:20:40 -06:00
}
/* Sends commands to set range compatible with Driving Force Pro wheel */
2015-04-08 14:56:40 -06:00
static void lg4ff_set_range_dfp ( struct hid_device * hid , u16 range )
2011-08-04 08:20:40 -06:00
{
2015-04-08 14:56:48 -06:00
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
unsigned long flags ;
2015-04-08 14:56:49 -06:00
int start_left , start_right , full_range ;
s32 * value ;
2012-09-23 17:09:30 -06:00
2015-04-08 14:56:48 -06:00
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return ;
}
2015-04-08 14:56:49 -06:00
value = entry - > report - > field [ 0 ] - > value ;
2011-08-04 08:20:40 -06:00
dbg_hid ( " Driving Force Pro: setting range to %u \n " , range ) ;
/* Prepare "coarse" limit command */
2015-04-08 14:56:48 -06:00
spin_lock_irqsave ( & entry - > report_lock , flags ) ;
2012-09-23 17:09:30 -06:00
value [ 0 ] = 0xf8 ;
2012-09-23 17:13:17 -06:00
value [ 1 ] = 0x00 ; /* Set later */
2012-09-23 17:09:30 -06:00
value [ 2 ] = 0x00 ;
value [ 3 ] = 0x00 ;
value [ 4 ] = 0x00 ;
value [ 5 ] = 0x00 ;
value [ 6 ] = 0x00 ;
2011-08-04 08:20:40 -06:00
if ( range > 200 ) {
2015-04-08 14:56:49 -06:00
value [ 1 ] = 0x03 ;
2011-08-04 08:20:40 -06:00
full_range = 900 ;
} else {
2015-04-08 14:56:49 -06:00
value [ 1 ] = 0x02 ;
2011-08-04 08:20:40 -06:00
full_range = 200 ;
}
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2011-08-04 08:20:40 -06:00
/* Prepare "fine" limit command */
2012-09-23 17:09:30 -06:00
value [ 0 ] = 0x81 ;
value [ 1 ] = 0x0b ;
value [ 2 ] = 0x00 ;
value [ 3 ] = 0x00 ;
value [ 4 ] = 0x00 ;
value [ 5 ] = 0x00 ;
value [ 6 ] = 0x00 ;
2011-08-04 08:20:40 -06:00
if ( range = = 200 | | range = = 900 ) { /* Do not apply any fine limit */
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2015-04-08 14:56:48 -06:00
spin_unlock_irqrestore ( & entry - > report_lock , flags ) ;
2011-08-04 08:20:40 -06:00
return ;
}
/* Construct fine limit command */
start_left = ( ( ( full_range - range + 1 ) * 2047 ) / full_range ) ;
start_right = 0xfff - start_left ;
2012-09-23 17:09:30 -06:00
value [ 2 ] = start_left > > 4 ;
value [ 3 ] = start_right > > 4 ;
value [ 4 ] = 0xff ;
value [ 5 ] = ( start_right & 0xe ) < < 4 | ( start_left & 0xe ) ;
value [ 6 ] = 0xff ;
2011-08-04 08:20:40 -06:00
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2015-04-08 14:56:48 -06:00
spin_unlock_irqrestore ( & entry - > report_lock , flags ) ;
2011-08-04 08:20:40 -06:00
}
2015-02-18 09:59:23 -07:00
static const struct lg4ff_compat_mode_switch * lg4ff_get_mode_switch_command ( const u16 real_product_id , const u16 target_product_id )
{
switch ( real_product_id ) {
case USB_DEVICE_ID_LOGITECH_DFP_WHEEL :
switch ( target_product_id ) {
case USB_DEVICE_ID_LOGITECH_DFP_WHEEL :
return & lg4ff_mode_switch_ext01_dfp ;
/* DFP can only be switched to its native mode */
default :
return NULL ;
}
break ;
case USB_DEVICE_ID_LOGITECH_G25_WHEEL :
switch ( target_product_id ) {
case USB_DEVICE_ID_LOGITECH_DFP_WHEEL :
return & lg4ff_mode_switch_ext01_dfp ;
case USB_DEVICE_ID_LOGITECH_G25_WHEEL :
return & lg4ff_mode_switch_ext16_g25 ;
/* G25 can only be switched to DFP mode or its native mode */
default :
return NULL ;
}
break ;
case USB_DEVICE_ID_LOGITECH_G27_WHEEL :
switch ( target_product_id ) {
case USB_DEVICE_ID_LOGITECH_WHEEL :
return & lg4ff_mode_switch_ext09_dfex ;
case USB_DEVICE_ID_LOGITECH_DFP_WHEEL :
return & lg4ff_mode_switch_ext09_dfp ;
case USB_DEVICE_ID_LOGITECH_G25_WHEEL :
return & lg4ff_mode_switch_ext09_g25 ;
case USB_DEVICE_ID_LOGITECH_G27_WHEEL :
return & lg4ff_mode_switch_ext09_g27 ;
/* G27 can only be switched to DF-EX, DFP, G25 or its native mode */
default :
return NULL ;
}
break ;
2015-11-02 07:56:52 -07:00
case USB_DEVICE_ID_LOGITECH_G29_WHEEL :
switch ( target_product_id ) {
case USB_DEVICE_ID_LOGITECH_DFP_WHEEL :
return & lg4ff_mode_switch_ext09_dfp ;
case USB_DEVICE_ID_LOGITECH_DFGT_WHEEL :
return & lg4ff_mode_switch_ext09_dfgt ;
case USB_DEVICE_ID_LOGITECH_G25_WHEEL :
return & lg4ff_mode_switch_ext09_g25 ;
case USB_DEVICE_ID_LOGITECH_G27_WHEEL :
return & lg4ff_mode_switch_ext09_g27 ;
case USB_DEVICE_ID_LOGITECH_G29_WHEEL :
return & lg4ff_mode_switch_ext09_g29 ;
/* G29 can only be switched to DF-EX, DFP, DFGT, G25, G27 or its native mode */
default :
return NULL ;
}
break ;
2015-02-18 09:59:23 -07:00
case USB_DEVICE_ID_LOGITECH_DFGT_WHEEL :
switch ( target_product_id ) {
case USB_DEVICE_ID_LOGITECH_WHEEL :
return & lg4ff_mode_switch_ext09_dfex ;
case USB_DEVICE_ID_LOGITECH_DFP_WHEEL :
return & lg4ff_mode_switch_ext09_dfp ;
case USB_DEVICE_ID_LOGITECH_DFGT_WHEEL :
return & lg4ff_mode_switch_ext09_dfgt ;
/* DFGT can only be switched to DF-EX, DFP or its native mode */
default :
return NULL ;
}
break ;
/* No other wheels have multiple modes */
default :
return NULL ;
}
}
2015-02-18 09:59:20 -07:00
static int lg4ff_switch_compatibility_mode ( struct hid_device * hid , const struct lg4ff_compat_mode_switch * s )
2011-08-04 08:18:11 -06:00
{
2015-04-08 14:56:48 -06:00
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
unsigned long flags ;
2015-04-08 14:56:49 -06:00
s32 * value ;
2015-02-18 09:59:20 -07:00
u8 i ;
2011-08-04 08:18:11 -06:00
2015-04-08 14:56:48 -06:00
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return - EINVAL ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return - EINVAL ;
}
2015-04-08 14:56:49 -06:00
value = entry - > report - > field [ 0 ] - > value ;
2015-04-08 14:56:48 -06:00
spin_lock_irqsave ( & entry - > report_lock , flags ) ;
2015-02-18 09:59:20 -07:00
for ( i = 0 ; i < s - > cmd_count ; i + + ) {
2015-02-18 14:49:33 -07:00
u8 j ;
2011-08-04 08:18:11 -06:00
2015-02-18 14:49:33 -07:00
for ( j = 0 ; j < 7 ; j + + )
value [ j ] = s - > cmd [ j + ( 7 * i ) ] ;
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2011-08-04 08:18:11 -06:00
}
2015-04-08 14:56:48 -06:00
spin_unlock_irqrestore ( & entry - > report_lock , flags ) ;
2015-02-18 14:49:33 -07:00
hid_hw_wait ( hid ) ;
2015-02-18 09:59:20 -07:00
return 0 ;
2011-08-04 08:18:11 -06:00
}
2010-09-22 05:19:42 -06:00
2015-02-18 09:59:21 -07:00
static ssize_t lg4ff_alternate_modes_show ( struct device * dev , struct device_attribute * attr , char * buf )
{
struct hid_device * hid = to_hid_device ( dev ) ;
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
ssize_t count = 0 ;
int i ;
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return 0 ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return 0 ;
}
2015-04-08 14:56:46 -06:00
if ( ! entry - > wdata . real_name ) {
2015-02-18 09:59:21 -07:00
hid_err ( hid , " NULL pointer to string \n " ) ;
return 0 ;
}
for ( i = 0 ; i < LG4FF_MODE_MAX_IDX ; i + + ) {
2015-04-08 14:56:46 -06:00
if ( entry - > wdata . alternate_modes & BIT ( i ) ) {
2015-02-18 09:59:21 -07:00
/* Print tag and full name */
count + = scnprintf ( buf + count , PAGE_SIZE - count , " %s: %s " ,
lg4ff_alternate_modes [ i ] . tag ,
2015-04-08 14:56:46 -06:00
! lg4ff_alternate_modes [ i ] . product_id ? entry - > wdata . real_name : lg4ff_alternate_modes [ i ] . name ) ;
2015-02-18 09:59:21 -07:00
if ( count > = PAGE_SIZE - 1 )
return count ;
/* Mark the currently active mode with an asterisk */
2015-04-08 14:56:46 -06:00
if ( lg4ff_alternate_modes [ i ] . product_id = = entry - > wdata . product_id | |
( lg4ff_alternate_modes [ i ] . product_id = = 0 & & entry - > wdata . product_id = = entry - > wdata . real_product_id ) )
2015-02-18 09:59:21 -07:00
count + = scnprintf ( buf + count , PAGE_SIZE - count , " * \n " ) ;
else
count + = scnprintf ( buf + count , PAGE_SIZE - count , " \n " ) ;
if ( count > = PAGE_SIZE - 1 )
return count ;
}
}
return count ;
}
static ssize_t lg4ff_alternate_modes_store ( struct device * dev , struct device_attribute * attr , const char * buf , size_t count )
{
2015-02-18 09:59:23 -07:00
struct hid_device * hid = to_hid_device ( dev ) ;
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
const struct lg4ff_compat_mode_switch * s ;
u16 target_product_id = 0 ;
int i , ret ;
char * lbuf ;
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return - EINVAL ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return - EINVAL ;
}
/* Allow \n at the end of the input parameter */
lbuf = kasprintf ( GFP_KERNEL , " %s " , buf ) ;
if ( ! lbuf )
return - ENOMEM ;
i = strlen ( lbuf ) ;
if ( lbuf [ i - 1 ] = = ' \n ' ) {
if ( i = = 1 ) {
kfree ( lbuf ) ;
return - EINVAL ;
}
lbuf [ i - 1 ] = ' \0 ' ;
}
for ( i = 0 ; i < LG4FF_MODE_MAX_IDX ; i + + ) {
const u16 mode_product_id = lg4ff_alternate_modes [ i ] . product_id ;
const char * tag = lg4ff_alternate_modes [ i ] . tag ;
2015-04-08 14:56:46 -06:00
if ( entry - > wdata . alternate_modes & BIT ( i ) ) {
2015-02-18 09:59:23 -07:00
if ( ! strcmp ( tag , lbuf ) ) {
if ( ! mode_product_id )
2015-04-08 14:56:46 -06:00
target_product_id = entry - > wdata . real_product_id ;
2015-02-18 09:59:23 -07:00
else
target_product_id = mode_product_id ;
break ;
}
}
}
if ( i = = LG4FF_MODE_MAX_IDX ) {
hid_info ( hid , " Requested mode \" %s \" is not supported by the device \n " , lbuf ) ;
kfree ( lbuf ) ;
return - EINVAL ;
}
kfree ( lbuf ) ; /* Not needed anymore */
2015-04-08 14:56:46 -06:00
if ( target_product_id = = entry - > wdata . product_id ) /* Nothing to do */
2015-02-18 09:59:23 -07:00
return count ;
/* Automatic switching has to be disabled for the switch to DF-EX mode to work correctly */
if ( target_product_id = = USB_DEVICE_ID_LOGITECH_WHEEL & & ! lg4ff_no_autoswitch ) {
hid_info ( hid , " \" %s \" cannot be switched to \" DF-EX \" mode. Load the \" hid_logitech \" module with \" lg4ff_no_autoswitch=1 \" parameter set and try again \n " ,
2015-04-08 14:56:46 -06:00
entry - > wdata . real_name ) ;
2015-02-18 09:59:23 -07:00
return - EINVAL ;
}
/* Take care of hardware limitations */
2015-04-08 14:56:46 -06:00
if ( ( entry - > wdata . real_product_id = = USB_DEVICE_ID_LOGITECH_DFP_WHEEL | | entry - > wdata . real_product_id = = USB_DEVICE_ID_LOGITECH_G25_WHEEL ) & &
entry - > wdata . product_id > target_product_id ) {
hid_info ( hid , " \" %s \" cannot be switched back into \" %s \" mode \n " , entry - > wdata . real_name , lg4ff_alternate_modes [ i ] . name ) ;
2015-02-18 09:59:23 -07:00
return - EINVAL ;
}
2015-04-08 14:56:46 -06:00
s = lg4ff_get_mode_switch_command ( entry - > wdata . real_product_id , target_product_id ) ;
2015-02-18 09:59:23 -07:00
if ( ! s ) {
hid_err ( hid , " Invalid target product ID %X \n " , target_product_id ) ;
return - EINVAL ;
}
ret = lg4ff_switch_compatibility_mode ( hid , s ) ;
return ( ret = = 0 ? count : ret ) ;
2015-02-18 09:59:21 -07:00
}
static DEVICE_ATTR ( alternate_modes , S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH , lg4ff_alternate_modes_show , lg4ff_alternate_modes_store ) ;
2016-09-18 10:55:37 -06:00
static ssize_t lg4ff_combine_show ( struct device * dev , struct device_attribute * attr ,
char * buf )
{
struct hid_device * hid = to_hid_device ( dev ) ;
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
size_t count ;
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return 0 ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return 0 ;
}
count = scnprintf ( buf , PAGE_SIZE , " %u \n " , entry - > wdata . combine ) ;
return count ;
}
static ssize_t lg4ff_combine_store ( struct device * dev , struct device_attribute * attr ,
const char * buf , size_t count )
{
struct hid_device * hid = to_hid_device ( dev ) ;
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
u16 combine = simple_strtoul ( buf , NULL , 10 ) ;
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return - EINVAL ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return - EINVAL ;
}
if ( combine > 1 )
combine = 1 ;
entry - > wdata . combine = combine ;
return count ;
}
static DEVICE_ATTR ( combine_pedals , S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH , lg4ff_combine_show , lg4ff_combine_store ) ;
2015-04-08 14:56:41 -06:00
/* Export the currently set range of the wheel */
static ssize_t lg4ff_range_show ( struct device * dev , struct device_attribute * attr ,
char * buf )
2011-08-04 08:20:40 -06:00
{
struct hid_device * hid = to_hid_device ( dev ) ;
2012-04-09 01:08:49 -06:00
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
2011-08-04 08:20:40 -06:00
size_t count ;
2012-04-09 01:08:49 -06:00
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return 0 ;
2011-08-04 08:20:40 -06:00
}
2012-04-09 01:08:49 -06:00
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
2011-08-04 08:20:40 -06:00
return 0 ;
}
2015-04-08 14:56:46 -06:00
count = scnprintf ( buf , PAGE_SIZE , " %u \n " , entry - > wdata . range ) ;
2011-08-04 08:20:40 -06:00
return count ;
}
/* Set range to user specified value, call appropriate function
* according to the type of the wheel */
2015-04-08 14:56:41 -06:00
static ssize_t lg4ff_range_store ( struct device * dev , struct device_attribute * attr ,
const char * buf , size_t count )
2011-08-04 08:20:40 -06:00
{
struct hid_device * hid = to_hid_device ( dev ) ;
2012-04-09 01:08:49 -06:00
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
2015-04-08 14:56:39 -06:00
u16 range = simple_strtoul ( buf , NULL , 10 ) ;
2011-08-04 08:20:40 -06:00
2012-04-09 01:08:49 -06:00
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
2014-08-14 20:43:01 -06:00
return - EINVAL ;
2011-08-04 08:20:40 -06:00
}
2012-04-09 01:08:49 -06:00
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
2014-08-14 20:43:01 -06:00
return - EINVAL ;
2011-08-04 08:20:40 -06:00
}
if ( range = = 0 )
2015-04-08 14:56:46 -06:00
range = entry - > wdata . max_range ;
2011-08-04 08:20:40 -06:00
/* Check if the wheel supports range setting
* and that the range is within limits for the wheel */
2015-04-08 14:56:46 -06:00
if ( entry - > wdata . set_range & & range > = entry - > wdata . min_range & & range < = entry - > wdata . max_range ) {
entry - > wdata . set_range ( hid , range ) ;
entry - > wdata . range = range ;
2011-08-04 08:20:40 -06:00
}
return count ;
}
2015-04-08 14:56:41 -06:00
static DEVICE_ATTR ( range , S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH , lg4ff_range_show , lg4ff_range_store ) ;
2011-08-04 08:20:40 -06:00
2015-02-18 09:59:21 -07:00
static ssize_t lg4ff_real_id_show ( struct device * dev , struct device_attribute * attr , char * buf )
{
struct hid_device * hid = to_hid_device ( dev ) ;
struct lg4ff_device_entry * entry ;
struct lg_drv_data * drv_data ;
size_t count ;
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return 0 ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return 0 ;
}
2015-04-08 14:56:46 -06:00
if ( ! entry - > wdata . real_tag | | ! entry - > wdata . real_name ) {
2015-02-18 09:59:21 -07:00
hid_err ( hid , " NULL pointer to string \n " ) ;
return 0 ;
}
2015-04-08 14:56:46 -06:00
count = scnprintf ( buf , PAGE_SIZE , " %s: %s \n " , entry - > wdata . real_tag , entry - > wdata . real_name ) ;
2015-02-18 09:59:21 -07:00
return count ;
}
static ssize_t lg4ff_real_id_store ( struct device * dev , struct device_attribute * attr , const char * buf , size_t count )
{
/* Real ID is a read-only value */
return - EPERM ;
}
static DEVICE_ATTR ( real_id , S_IRUGO , lg4ff_real_id_show , lg4ff_real_id_store ) ;
2012-04-21 06:41:15 -06:00
# ifdef CONFIG_LEDS_CLASS
2015-04-08 14:56:39 -06:00
static void lg4ff_set_leds ( struct hid_device * hid , u8 leds )
2012-04-21 06:41:15 -06:00
{
2015-04-08 14:56:48 -06:00
struct lg_drv_data * drv_data ;
struct lg4ff_device_entry * entry ;
unsigned long flags ;
2015-04-08 14:56:49 -06:00
s32 * value ;
2012-09-23 17:09:30 -06:00
2015-04-08 14:56:48 -06:00
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Private driver data not found! \n " ) ;
return ;
}
entry = drv_data - > device_props ;
if ( ! entry ) {
hid_err ( hid , " Device properties not found! \n " ) ;
return ;
}
2015-04-08 14:56:49 -06:00
value = entry - > report - > field [ 0 ] - > value ;
2015-04-08 14:56:48 -06:00
spin_lock_irqsave ( & entry - > report_lock , flags ) ;
2012-09-23 17:09:30 -06:00
value [ 0 ] = 0xf8 ;
value [ 1 ] = 0x12 ;
value [ 2 ] = leds ;
value [ 3 ] = 0x00 ;
value [ 4 ] = 0x00 ;
value [ 5 ] = 0x00 ;
value [ 6 ] = 0x00 ;
2015-04-08 14:56:49 -06:00
hid_hw_request ( hid , entry - > report , HID_REQ_SET_REPORT ) ;
2015-04-08 14:56:48 -06:00
spin_unlock_irqrestore ( & entry - > report_lock , flags ) ;
2012-04-21 06:41:15 -06:00
}
static void lg4ff_led_set_brightness ( struct led_classdev * led_cdev ,
enum led_brightness value )
{
struct device * dev = led_cdev - > dev - > parent ;
2015-12-27 02:25:21 -07:00
struct hid_device * hid = to_hid_device ( dev ) ;
2012-09-13 00:09:33 -06:00
struct lg_drv_data * drv_data = hid_get_drvdata ( hid ) ;
2012-04-21 06:41:15 -06:00
struct lg4ff_device_entry * entry ;
int i , state = 0 ;
if ( ! drv_data ) {
hid_err ( hid , " Device data not found. " ) ;
return ;
}
2015-04-08 14:56:43 -06:00
entry = drv_data - > device_props ;
2012-04-21 06:41:15 -06:00
if ( ! entry ) {
hid_err ( hid , " Device properties not found. " ) ;
return ;
}
for ( i = 0 ; i < 5 ; i + + ) {
2015-04-08 14:56:46 -06:00
if ( led_cdev ! = entry - > wdata . led [ i ] )
2012-04-21 06:41:15 -06:00
continue ;
2015-04-08 14:56:46 -06:00
state = ( entry - > wdata . led_state > > i ) & 1 ;
2012-04-21 06:41:15 -06:00
if ( value = = LED_OFF & & state ) {
2015-04-08 14:56:46 -06:00
entry - > wdata . led_state & = ~ ( 1 < < i ) ;
lg4ff_set_leds ( hid , entry - > wdata . led_state ) ;
2012-04-21 06:41:15 -06:00
} else if ( value ! = LED_OFF & & ! state ) {
2015-04-08 14:56:46 -06:00
entry - > wdata . led_state | = 1 < < i ;
lg4ff_set_leds ( hid , entry - > wdata . led_state ) ;
2012-04-21 06:41:15 -06:00
}
break ;
}
}
static enum led_brightness lg4ff_led_get_brightness ( struct led_classdev * led_cdev )
{
struct device * dev = led_cdev - > dev - > parent ;
2015-12-27 02:25:21 -07:00
struct hid_device * hid = to_hid_device ( dev ) ;
2012-09-13 00:09:33 -06:00
struct lg_drv_data * drv_data = hid_get_drvdata ( hid ) ;
2012-04-21 06:41:15 -06:00
struct lg4ff_device_entry * entry ;
int i , value = 0 ;
if ( ! drv_data ) {
hid_err ( hid , " Device data not found. " ) ;
return LED_OFF ;
}
2015-04-08 14:56:43 -06:00
entry = drv_data - > device_props ;
2012-04-21 06:41:15 -06:00
if ( ! entry ) {
hid_err ( hid , " Device properties not found. " ) ;
return LED_OFF ;
}
for ( i = 0 ; i < 5 ; i + + )
2015-04-08 14:56:46 -06:00
if ( led_cdev = = entry - > wdata . led [ i ] ) {
value = ( entry - > wdata . led_state > > i ) & 1 ;
2012-04-21 06:41:15 -06:00
break ;
}
return value ? LED_FULL : LED_OFF ;
}
# endif
2015-02-18 09:59:20 -07:00
static u16 lg4ff_identify_multimode_wheel ( struct hid_device * hid , const u16 reported_product_id , const u16 bcdDevice )
{
2015-11-02 07:56:51 -07:00
u32 current_mode ;
int i ;
2015-02-18 09:59:20 -07:00
2015-11-02 07:56:51 -07:00
/* identify current mode from USB PID */
for ( i = 1 ; i < ARRAY_SIZE ( lg4ff_alternate_modes ) ; i + + ) {
dbg_hid ( " Testing whether PID is %X \n " , lg4ff_alternate_modes [ i ] . product_id ) ;
if ( reported_product_id = = lg4ff_alternate_modes [ i ] . product_id )
break ;
2015-02-18 09:59:20 -07:00
}
2015-11-02 07:56:51 -07:00
if ( i = = ARRAY_SIZE ( lg4ff_alternate_modes ) )
return 0 ;
current_mode = BIT ( i ) ;
for ( i = 0 ; i < ARRAY_SIZE ( lg4ff_main_checklist ) ; i + + ) {
const u16 mask = lg4ff_main_checklist [ i ] - > mask ;
const u16 result = lg4ff_main_checklist [ i ] - > result ;
const u16 real_product_id = lg4ff_main_checklist [ i ] - > real_product_id ;
2015-02-18 09:59:20 -07:00
2015-11-02 07:56:51 -07:00
if ( ( current_mode & lg4ff_main_checklist [ i ] - > modes ) & & \
( bcdDevice & mask ) = = result ) {
2015-02-18 09:59:20 -07:00
dbg_hid ( " Found wheel with real PID %X whose reported PID is %X \n " , real_product_id , reported_product_id ) ;
return real_product_id ;
}
}
2015-02-18 09:59:23 -07:00
/* No match found. This is either Driving Force or an unknown
* wheel model , do not touch it */
2015-02-18 09:59:20 -07:00
dbg_hid ( " Wheel with bcdDevice %X was not recognized as multimode wheel, leaving in its current mode \n " , bcdDevice ) ;
return 0 ;
}
static int lg4ff_handle_multimode_wheel ( struct hid_device * hid , u16 * real_product_id , const u16 bcdDevice )
{
const u16 reported_product_id = hid - > product ;
int ret ;
* real_product_id = lg4ff_identify_multimode_wheel ( hid , reported_product_id , bcdDevice ) ;
/* Probed wheel is not a multimode wheel */
if ( ! * real_product_id ) {
* real_product_id = reported_product_id ;
dbg_hid ( " Wheel is not a multimode wheel \n " ) ;
return LG4FF_MMODE_NOT_MULTIMODE ;
}
/* Switch from "Driving Force" mode to native mode automatically.
* Otherwise keep the wheel in its current mode */
if ( reported_product_id = = USB_DEVICE_ID_LOGITECH_WHEEL & &
2015-02-18 09:59:22 -07:00
reported_product_id ! = * real_product_id & &
! lg4ff_no_autoswitch ) {
2015-02-18 09:59:23 -07:00
const struct lg4ff_compat_mode_switch * s = lg4ff_get_mode_switch_command ( * real_product_id , * real_product_id ) ;
2015-02-18 09:59:20 -07:00
2015-02-18 09:59:23 -07:00
if ( ! s ) {
2015-02-18 09:59:20 -07:00
hid_err ( hid , " Invalid product id %X \n " , * real_product_id ) ;
2015-02-18 09:59:21 -07:00
return LG4FF_MMODE_NOT_MULTIMODE ;
2015-02-18 09:59:20 -07:00
}
ret = lg4ff_switch_compatibility_mode ( hid , s ) ;
if ( ret ) {
/* Wheel could not have been switched to native mode,
* leave it in " Driving Force " mode and continue */
hid_err ( hid , " Unable to switch wheel mode, errno %d \n " , ret ) ;
2015-02-18 09:59:21 -07:00
return LG4FF_MMODE_IS_MULTIMODE ;
2015-02-18 09:59:20 -07:00
}
return LG4FF_MMODE_SWITCHED ;
}
2015-02-18 09:59:21 -07:00
return LG4FF_MMODE_IS_MULTIMODE ;
2015-02-18 09:59:20 -07:00
}
2010-09-22 05:19:42 -06:00
int lg4ff_init ( struct hid_device * hid )
{
struct hid_input * hidinput = list_entry ( hid - > inputs . next , struct hid_input , list ) ;
struct input_dev * dev = hidinput - > input ;
2015-04-08 14:56:49 -06:00
struct list_head * report_list = & hid - > report_enum [ HID_OUTPUT_REPORT ] . report_list ;
struct hid_report * report = list_entry ( report_list - > next , struct hid_report , list ) ;
2015-02-18 09:59:20 -07:00
const struct usb_device_descriptor * udesc = & ( hid_to_usb_dev ( hid ) - > descriptor ) ;
const u16 bcdDevice = le16_to_cpu ( udesc - > bcdDevice ) ;
2015-04-08 14:56:50 -06:00
const struct lg4ff_multimode_wheel * mmode_wheel = NULL ;
2011-08-04 08:20:40 -06:00
struct lg4ff_device_entry * entry ;
2012-04-09 01:08:49 -06:00
struct lg_drv_data * drv_data ;
2015-02-18 09:59:21 -07:00
int error , i , j ;
int mmode_ret , mmode_idx = - 1 ;
2015-02-18 09:59:20 -07:00
u16 real_product_id ;
2010-09-22 05:19:42 -06:00
/* Check that the report looks ok */
2013-09-11 13:56:54 -06:00
if ( ! hid_validate_values ( hid , HID_OUTPUT_REPORT , 0 , 0 , 7 ) )
2010-09-22 05:19:42 -06:00
return - 1 ;
2011-08-04 08:20:40 -06:00
2015-04-08 14:56:46 -06:00
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Cannot add device, private driver data not allocated \n " ) ;
return - 1 ;
}
entry = kzalloc ( sizeof ( * entry ) , GFP_KERNEL ) ;
if ( ! entry )
return - ENOMEM ;
2015-04-08 14:56:48 -06:00
spin_lock_init ( & entry - > report_lock ) ;
2015-04-08 14:56:49 -06:00
entry - > report = report ;
2015-04-08 14:56:46 -06:00
drv_data - > device_props = entry ;
2015-02-18 09:59:20 -07:00
/* Check if a multimode wheel has been connected and
* handle it appropriately */
2015-02-18 09:59:21 -07:00
mmode_ret = lg4ff_handle_multimode_wheel ( hid , & real_product_id , bcdDevice ) ;
2015-02-18 09:59:20 -07:00
/* Wheel has been told to switch to native mode. There is no point in going on
* with the initialization as the wheel will do a USB reset when it switches mode
*/
2015-02-18 09:59:21 -07:00
if ( mmode_ret = = LG4FF_MMODE_SWITCHED )
2015-02-18 09:59:20 -07:00
return 0 ;
2015-04-08 14:56:46 -06:00
else if ( mmode_ret < 0 ) {
hid_err ( hid , " Unable to switch device mode during initialization, errno %d \n " , mmode_ret ) ;
error = mmode_ret ;
goto err_init ;
}
2015-02-18 09:59:20 -07:00
HID: lg4ff - Move handling of Logitech wheels to lg4ff driver
This is the first out of five patches me and Simon Wood (CC'd) have been
working on. It separates the handling of Logite from the generic lgff driver
and adds additional features specific for the Logitech wheels, namely
- Native mode support for Driving Force GT, Driving Force Pro, G25 and G27
wheels Every Logitech wheel reports itself as generic Logitech Driving Force
wheel (VID 046d, PID c294). This is done to ensu wheel will work on every USB
HID-aware system even when no Logitech driver is available. It however limits
the capabilit wheel - range is limited to 200 degrees, G25/G27 don't report the
clutch pedal and there is only one combined axis for t brake. The switch to
native mode is done via hardware-specific command which is different for each
wheel. When the wheel receives such command, it simulates reconnect and reports
to the OS with its actual PID.
- Adjustable wheel range DFGT, DFP, G25 and G27 have variable range of the
steering wheel. The range is limited by applying a maximum constant when the
wheel is turned beyond the allowed range. The limit as also set by a
hardware-specific command. There is a comm command for DFGT, G25 and G27 and
another one for DFP. It is probably possible to use the DFP command to limit
the range other Logitech wheels too, but this is not supported by the official
Logitech driver for Windows. The patch adds a sysfs interface which allows for
the range to be set from userspace.
- Fixed autocentering command All Logitech wheels support FF_AUTOCENTER effect.
The original implementation in the lgff driver didn't work well with patch
fixes it. According to USB communication sniffs the Formula Force EX (pretty
much rebranded original Driving Force accept the generic autocentering command,
this issue is also addressed by the patch
There are still some features this patch doesn't cover, but since some of them
will most likely require modifications of memless driver we have decided not to
include them yet.
As first we decided to move the handling of Logitech wheels from hid-lgff
driver to hid-lg4ff driver (originally used fo At also adds PID of Logitech
Driving Force GT.
Signed-off-by: Michal Malý <madcatxster@gmail.com>
Signed-off-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-08-04 08:16:09 -06:00
/* Check what wheel has been connected */
for ( i = 0 ; i < ARRAY_SIZE ( lg4ff_devices ) ; i + + ) {
if ( hid - > product = = lg4ff_devices [ i ] . product_id ) {
dbg_hid ( " Found compatible device, product ID %04X \n " , lg4ff_devices [ i ] . product_id ) ;
break ;
}
}
if ( i = = ARRAY_SIZE ( lg4ff_devices ) ) {
2015-04-08 14:56:44 -06:00
hid_err ( hid , " This device is flagged to be handled by the lg4ff module but this module does not know how to handle it. "
" Please report this as a bug to LKML, Simon Wood <simon@mungewell.org> or "
" Michal Maly <madcatxster@devoid-pointer.net> \n " ) ;
2015-04-08 14:56:46 -06:00
error = - 1 ;
goto err_init ;
HID: lg4ff - Move handling of Logitech wheels to lg4ff driver
This is the first out of five patches me and Simon Wood (CC'd) have been
working on. It separates the handling of Logite from the generic lgff driver
and adds additional features specific for the Logitech wheels, namely
- Native mode support for Driving Force GT, Driving Force Pro, G25 and G27
wheels Every Logitech wheel reports itself as generic Logitech Driving Force
wheel (VID 046d, PID c294). This is done to ensu wheel will work on every USB
HID-aware system even when no Logitech driver is available. It however limits
the capabilit wheel - range is limited to 200 degrees, G25/G27 don't report the
clutch pedal and there is only one combined axis for t brake. The switch to
native mode is done via hardware-specific command which is different for each
wheel. When the wheel receives such command, it simulates reconnect and reports
to the OS with its actual PID.
- Adjustable wheel range DFGT, DFP, G25 and G27 have variable range of the
steering wheel. The range is limited by applying a maximum constant when the
wheel is turned beyond the allowed range. The limit as also set by a
hardware-specific command. There is a comm command for DFGT, G25 and G27 and
another one for DFP. It is probably possible to use the DFP command to limit
the range other Logitech wheels too, but this is not supported by the official
Logitech driver for Windows. The patch adds a sysfs interface which allows for
the range to be set from userspace.
- Fixed autocentering command All Logitech wheels support FF_AUTOCENTER effect.
The original implementation in the lgff driver didn't work well with patch
fixes it. According to USB communication sniffs the Formula Force EX (pretty
much rebranded original Driving Force accept the generic autocentering command,
this issue is also addressed by the patch
There are still some features this patch doesn't cover, but since some of them
will most likely require modifications of memless driver we have decided not to
include them yet.
As first we decided to move the handling of Logitech wheels from hid-lgff
driver to hid-lg4ff driver (originally used fo At also adds PID of Logitech
Driving Force GT.
Signed-off-by: Michal Malý <madcatxster@gmail.com>
Signed-off-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-08-04 08:16:09 -06:00
}
2010-09-22 05:19:42 -06:00
2015-02-18 09:59:21 -07:00
if ( mmode_ret = = LG4FF_MMODE_IS_MULTIMODE ) {
for ( mmode_idx = 0 ; mmode_idx < ARRAY_SIZE ( lg4ff_multimode_wheels ) ; mmode_idx + + ) {
if ( real_product_id = = lg4ff_multimode_wheels [ mmode_idx ] . product_id )
break ;
}
if ( mmode_idx = = ARRAY_SIZE ( lg4ff_multimode_wheels ) ) {
hid_err ( hid , " Device product ID %X is not listed as a multimode wheel " , real_product_id ) ;
2015-04-08 14:56:46 -06:00
error = - 1 ;
goto err_init ;
2015-02-18 09:59:21 -07:00
}
}
HID: lg4ff - Move handling of Logitech wheels to lg4ff driver
This is the first out of five patches me and Simon Wood (CC'd) have been
working on. It separates the handling of Logite from the generic lgff driver
and adds additional features specific for the Logitech wheels, namely
- Native mode support for Driving Force GT, Driving Force Pro, G25 and G27
wheels Every Logitech wheel reports itself as generic Logitech Driving Force
wheel (VID 046d, PID c294). This is done to ensu wheel will work on every USB
HID-aware system even when no Logitech driver is available. It however limits
the capabilit wheel - range is limited to 200 degrees, G25/G27 don't report the
clutch pedal and there is only one combined axis for t brake. The switch to
native mode is done via hardware-specific command which is different for each
wheel. When the wheel receives such command, it simulates reconnect and reports
to the OS with its actual PID.
- Adjustable wheel range DFGT, DFP, G25 and G27 have variable range of the
steering wheel. The range is limited by applying a maximum constant when the
wheel is turned beyond the allowed range. The limit as also set by a
hardware-specific command. There is a comm command for DFGT, G25 and G27 and
another one for DFP. It is probably possible to use the DFP command to limit
the range other Logitech wheels too, but this is not supported by the official
Logitech driver for Windows. The patch adds a sysfs interface which allows for
the range to be set from userspace.
- Fixed autocentering command All Logitech wheels support FF_AUTOCENTER effect.
The original implementation in the lgff driver didn't work well with patch
fixes it. According to USB communication sniffs the Formula Force EX (pretty
much rebranded original Driving Force accept the generic autocentering command,
this issue is also addressed by the patch
There are still some features this patch doesn't cover, but since some of them
will most likely require modifications of memless driver we have decided not to
include them yet.
As first we decided to move the handling of Logitech wheels from hid-lgff
driver to hid-lg4ff driver (originally used fo At also adds PID of Logitech
Driving Force GT.
Signed-off-by: Michal Malý <madcatxster@gmail.com>
Signed-off-by: Simon Wood <simon@mungewell.org>
Signed-off-by: Jiri Kosina <jkosina@suse.cz>
2011-08-04 08:16:09 -06:00
/* Set supported force feedback capabilities */
for ( j = 0 ; lg4ff_devices [ i ] . ff_effects [ j ] > = 0 ; j + + )
set_bit ( lg4ff_devices [ i ] . ff_effects [ j ] , dev - > ffbit ) ;
2010-09-22 05:19:42 -06:00
2015-04-08 14:56:40 -06:00
error = input_ff_create_memless ( dev , NULL , lg4ff_play ) ;
2010-09-22 05:19:42 -06:00
if ( error )
2015-04-08 14:56:46 -06:00
goto err_init ;
2011-08-04 08:20:40 -06:00
2015-04-08 14:56:50 -06:00
/* Initialize device properties */
2015-02-18 09:59:21 -07:00
if ( mmode_ret = = LG4FF_MMODE_IS_MULTIMODE ) {
BUG_ON ( mmode_idx = = - 1 ) ;
2015-04-08 14:56:50 -06:00
mmode_wheel = & lg4ff_multimode_wheels [ mmode_idx ] ;
2015-02-18 09:59:21 -07:00
}
2015-04-08 14:56:50 -06:00
lg4ff_init_wheel_data ( & entry - > wdata , & lg4ff_devices [ i ] , mmode_wheel , real_product_id ) ;
2011-08-04 08:20:40 -06:00
2013-11-06 12:30:43 -07:00
/* Check if autocentering is available and
* set the centering force to zero by default */
if ( test_bit ( FF_AUTOCENTER , dev - > ffbit ) ) {
2015-02-18 09:59:20 -07:00
/* Formula Force EX expects different autocentering command */
if ( ( bcdDevice > > 8 ) = = LG4FF_FFEX_REV_MAJ & &
( bcdDevice & 0xff ) = = LG4FF_FFEX_REV_MIN )
2015-04-08 14:56:40 -06:00
dev - > ff - > set_autocenter = lg4ff_set_autocenter_ffex ;
2013-11-06 12:30:43 -07:00
else
2015-04-08 14:56:40 -06:00
dev - > ff - > set_autocenter = lg4ff_set_autocenter_default ;
2013-11-06 12:30:43 -07:00
dev - > ff - > set_autocenter ( dev , 0 ) ;
}
2011-08-04 08:20:40 -06:00
/* Create sysfs interface */
2016-09-18 10:55:37 -06:00
error = device_create_file ( & hid - > dev , & dev_attr_combine_pedals ) ;
if ( error )
hid_warn ( hid , " Unable to create sysfs interface for \" combine \" , errno %d \n " , error ) ;
2011-08-04 08:20:40 -06:00
error = device_create_file ( & hid - > dev , & dev_attr_range ) ;
if ( error )
2015-04-08 14:56:51 -06:00
hid_warn ( hid , " Unable to create sysfs interface for \" range \" , errno %d \n " , error ) ;
2015-02-18 09:59:21 -07:00
if ( mmode_ret = = LG4FF_MMODE_IS_MULTIMODE ) {
error = device_create_file ( & hid - > dev , & dev_attr_real_id ) ;
if ( error )
2015-04-08 14:56:51 -06:00
hid_warn ( hid , " Unable to create sysfs interface for \" real_id \" , errno %d \n " , error ) ;
2015-02-18 09:59:21 -07:00
error = device_create_file ( & hid - > dev , & dev_attr_alternate_modes ) ;
if ( error )
2015-04-08 14:56:51 -06:00
hid_warn ( hid , " Unable to create sysfs interface for \" alternate_modes \" , errno %d \n " , error ) ;
2015-02-18 09:59:21 -07:00
}
2011-08-04 08:20:40 -06:00
dbg_hid ( " sysfs interface created \n " ) ;
/* Set the maximum range to start with */
2015-04-08 14:56:46 -06:00
entry - > wdata . range = entry - > wdata . max_range ;
if ( entry - > wdata . set_range )
entry - > wdata . set_range ( hid , entry - > wdata . range ) ;
2011-08-04 08:20:40 -06:00
2012-04-21 06:41:15 -06:00
# ifdef CONFIG_LEDS_CLASS
2015-11-02 07:56:52 -07:00
/* register led subsystem - G27/G29 only */
2015-04-08 14:56:46 -06:00
entry - > wdata . led_state = 0 ;
2012-04-21 06:41:15 -06:00
for ( j = 0 ; j < 5 ; j + + )
2015-04-08 14:56:46 -06:00
entry - > wdata . led [ j ] = NULL ;
2012-04-21 06:41:15 -06:00
2015-11-02 07:56:52 -07:00
if ( lg4ff_devices [ i ] . product_id = = USB_DEVICE_ID_LOGITECH_G27_WHEEL | |
lg4ff_devices [ i ] . product_id = = USB_DEVICE_ID_LOGITECH_G29_WHEEL ) {
2012-04-21 06:41:15 -06:00
struct led_classdev * led ;
size_t name_sz ;
char * name ;
lg4ff_set_leds ( hid , 0 ) ;
name_sz = strlen ( dev_name ( & hid - > dev ) ) + 8 ;
for ( j = 0 ; j < 5 ; j + + ) {
led = kzalloc ( sizeof ( struct led_classdev ) + name_sz , GFP_KERNEL ) ;
if ( ! led ) {
hid_err ( hid , " can't allocate memory for LED %d \n " , j ) ;
2015-04-08 14:56:46 -06:00
goto err_leds ;
2012-04-21 06:41:15 -06:00
}
name = ( void * ) ( & led [ 1 ] ) ;
snprintf ( name , name_sz , " %s::RPM%d " , dev_name ( & hid - > dev ) , j + 1 ) ;
led - > name = name ;
led - > brightness = 0 ;
led - > max_brightness = 1 ;
led - > brightness_get = lg4ff_led_get_brightness ;
led - > brightness_set = lg4ff_led_set_brightness ;
2015-04-08 14:56:46 -06:00
entry - > wdata . led [ j ] = led ;
2012-04-21 06:41:15 -06:00
error = led_classdev_register ( & hid - > dev , led ) ;
if ( error ) {
hid_err ( hid , " failed to register LED %d. Aborting. \n " , j ) ;
2015-04-08 14:56:46 -06:00
err_leds :
2012-04-21 06:41:15 -06:00
/* Deregister LEDs (if any) */
for ( j = 0 ; j < 5 ; j + + ) {
2015-04-08 14:56:46 -06:00
led = entry - > wdata . led [ j ] ;
entry - > wdata . led [ j ] = NULL ;
2012-04-21 06:41:15 -06:00
if ( ! led )
continue ;
led_classdev_unregister ( led ) ;
kfree ( led ) ;
}
goto out ; /* Let the driver continue without LEDs */
}
}
}
out :
2012-04-23 13:08:15 -06:00
# endif
2012-04-21 06:41:16 -06:00
hid_info ( hid , " Force feedback support for Logitech Gaming Wheels \n " ) ;
2010-09-22 05:19:42 -06:00
return 0 ;
2015-04-08 14:56:46 -06:00
err_init :
drv_data - > device_props = NULL ;
kfree ( entry ) ;
return error ;
2010-09-22 05:19:42 -06:00
}
2011-08-04 08:20:40 -06:00
int lg4ff_deinit ( struct hid_device * hid )
{
struct lg4ff_device_entry * entry ;
2012-04-09 01:08:49 -06:00
struct lg_drv_data * drv_data ;
drv_data = hid_get_drvdata ( hid ) ;
if ( ! drv_data ) {
hid_err ( hid , " Error while deinitializing device, no private driver data. \n " ) ;
return - 1 ;
2011-08-04 08:20:40 -06:00
}
2012-04-09 01:08:49 -06:00
entry = drv_data - > device_props ;
2015-02-18 09:59:20 -07:00
if ( ! entry )
goto out ; /* Nothing more to do */
2015-02-18 09:59:21 -07:00
/* Multimode devices will have at least the "MODE_NATIVE" bit set */
2015-04-08 14:56:46 -06:00
if ( entry - > wdata . alternate_modes ) {
2015-02-18 09:59:21 -07:00
device_remove_file ( & hid - > dev , & dev_attr_real_id ) ;
device_remove_file ( & hid - > dev , & dev_attr_alternate_modes ) ;
}
2016-09-18 10:55:37 -06:00
device_remove_file ( & hid - > dev , & dev_attr_combine_pedals ) ;
2015-04-08 14:56:46 -06:00
device_remove_file ( & hid - > dev , & dev_attr_range ) ;
2012-04-21 06:41:15 -06:00
# ifdef CONFIG_LEDS_CLASS
{
int j ;
struct led_classdev * led ;
/* Deregister LEDs (if any) */
for ( j = 0 ; j < 5 ; j + + ) {
2015-04-08 14:56:46 -06:00
led = entry - > wdata . led [ j ] ;
entry - > wdata . led [ j ] = NULL ;
2012-04-21 06:41:15 -06:00
if ( ! led )
continue ;
led_classdev_unregister ( led ) ;
kfree ( led ) ;
}
}
# endif
2015-04-08 14:56:47 -06:00
hid_hw_stop ( hid ) ;
drv_data - > device_props = NULL ;
2012-04-21 06:41:15 -06:00
2012-04-09 01:08:49 -06:00
kfree ( entry ) ;
2015-02-18 09:59:20 -07:00
out :
2011-08-04 08:20:40 -06:00
dbg_hid ( " Device successfully unregistered \n " ) ;
return 0 ;
}