lkml.org 
[lkml]   [2018]   [Oct]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
SubjectRe: [PATCH] HID: steam: remove input device when a hid client is running.
From
Date


On 10/14/18 10:36 AM, Rodrigo Rivas Costa wrote:
> Previously, when a HID client such as the Steam Client was running, this
> driver disabled its input device to avoid doubling the input events.
>
> While it worked mostly fine, some games got confused by the idle gamepad,
> and switched to two player mode, or asked the user to choose which gamepad
> to use. Other games just crashed, probably a bug in Unity [1].
>
> With this commit, when a HID client starts, the input device is removed;
> when the HID client ends the input device is recreated.
>
> [1]: https://github.com/ValveSoftware/steam-for-linux/issues/5645

Hi Rodrigo,

Thanks a lot, this should indeed help a ton. Just the presence of an
extra gamepad node can indeed cause applications to go completely
different paths. Assuming it otherwise looks good, is there a chance
this fix could be put back into the 4.18 branch?

Thanks,
- Pierre-Loup

>
> Signed-off-by: Rodrigo Rivas Costa <rodrigorivascosta@gmail.com>
> ---
> drivers/hid/hid-steam.c | 154 +++++++++++++++++++++++-----------------
> 1 file changed, 90 insertions(+), 64 deletions(-)
>
> diff --git a/drivers/hid/hid-steam.c b/drivers/hid/hid-steam.c
> index 0422ec2b13d2..dc4128bfe2ca 100644
> --- a/drivers/hid/hid-steam.c
> +++ b/drivers/hid/hid-steam.c
> @@ -23,8 +23,9 @@
> * In order to avoid breaking them this driver creates a layered hidraw device,
> * so it can detect when the client is running and then:
> * - it will not send any command to the controller.
> - * - this input device will be disabled, to avoid double input of the same
> + * - this input device will be removed, to avoid double input of the same
> * user action.
> + * When the client is closed, this input device will be created again.
> *
> * For additional functions, such as changing the right-pad margin or switching
> * the led, you can use the user-space tool at:
> @@ -113,7 +114,7 @@ struct steam_device {
> spinlock_t lock;
> struct hid_device *hdev, *client_hdev;
> struct mutex mutex;
> - bool client_opened, input_opened;
> + bool client_opened;
> struct input_dev __rcu *input;
> unsigned long quirks;
> struct work_struct work_connect;
> @@ -279,18 +280,6 @@ static void steam_set_lizard_mode(struct steam_device *steam, bool enable)
> }
> }
>
> -static void steam_update_lizard_mode(struct steam_device *steam)
> -{
> - mutex_lock(&steam->mutex);
> - if (!steam->client_opened) {
> - if (steam->input_opened)
> - steam_set_lizard_mode(steam, false);
> - else
> - steam_set_lizard_mode(steam, lizard_mode);
> - }
> - mutex_unlock(&steam->mutex);
> -}
> -
> static int steam_input_open(struct input_dev *dev)
> {
> struct steam_device *steam = input_get_drvdata(dev);
> @@ -301,7 +290,6 @@ static int steam_input_open(struct input_dev *dev)
> return ret;
>
> mutex_lock(&steam->mutex);
> - steam->input_opened = true;
> if (!steam->client_opened && lizard_mode)
> steam_set_lizard_mode(steam, false);
> mutex_unlock(&steam->mutex);
> @@ -313,7 +301,6 @@ static void steam_input_close(struct input_dev *dev)
> struct steam_device *steam = input_get_drvdata(dev);
>
> mutex_lock(&steam->mutex);
> - steam->input_opened = false;
> if (!steam->client_opened && lizard_mode)
> steam_set_lizard_mode(steam, true);
> mutex_unlock(&steam->mutex);
> @@ -400,7 +387,7 @@ static int steam_battery_register(struct steam_device *steam)
> return 0;
> }
>
> -static int steam_register(struct steam_device *steam)
> +static int steam_input_register(struct steam_device *steam)
> {
> struct hid_device *hdev = steam->hdev;
> struct input_dev *input;
> @@ -414,17 +401,6 @@ static int steam_register(struct steam_device *steam)
> return 0;
> }
>
> - /*
> - * Unlikely, but getting the serial could fail, and it is not so
> - * important, so make up a serial number and go on.
> - */
> - if (steam_get_serial(steam) < 0)
> - strlcpy(steam->serial_no, "XXXXXXXXXX",
> - sizeof(steam->serial_no));
> -
> - hid_info(hdev, "Steam Controller '%s' connected",
> - steam->serial_no);
> -
> input = input_allocate_device();
> if (!input)
> return -ENOMEM;
> @@ -492,11 +468,6 @@ static int steam_register(struct steam_device *steam)
> goto input_register_fail;
>
> rcu_assign_pointer(steam->input, input);
> -
> - /* ignore battery errors, we can live without it */
> - if (steam->quirks & STEAM_QUIRK_WIRELESS)
> - steam_battery_register(steam);
> -
> return 0;
>
> input_register_fail:
> @@ -504,27 +475,88 @@ static int steam_register(struct steam_device *steam)
> return ret;
> }
>
> -static void steam_unregister(struct steam_device *steam)
> +static void steam_input_unregister(struct steam_device *steam)
> {
> struct input_dev *input;
> + rcu_read_lock();
> + input = rcu_dereference(steam->input);
> + rcu_read_unlock();
> + if (!input)
> + return;
> + RCU_INIT_POINTER(steam->input, NULL);
> + synchronize_rcu();
> + input_unregister_device(input);
> +}
> +
> +static void steam_battery_unregister(struct steam_device *steam)
> +{
> struct power_supply *battery;
>
> rcu_read_lock();
> - input = rcu_dereference(steam->input);
> battery = rcu_dereference(steam->battery);
> rcu_read_unlock();
>
> - if (battery) {
> - RCU_INIT_POINTER(steam->battery, NULL);
> - synchronize_rcu();
> - power_supply_unregister(battery);
> + if (!battery)
> + return;
> + RCU_INIT_POINTER(steam->battery, NULL);
> + synchronize_rcu();
> + power_supply_unregister(battery);
> +}
> +
> +static int steam_register(struct steam_device *steam)
> +{
> + int ret;
> +
> + /*
> + * This function can be called several times in a row with the
> + * wireless adaptor, without steam_unregister() between them, because
> + * another client send a get_connection_status command, for example.
> + * The battery and serial number are set just once per device.
> + */
> + if (!steam->serial_no[0]) {
> + /*
> + * Unlikely, but getting the serial could fail, and it is not so
> + * important, so make up a serial number and go on.
> + */
> + if (steam_get_serial(steam) < 0)
> + strlcpy(steam->serial_no, "XXXXXXXXXX",
> + sizeof(steam->serial_no));
> +
> + hid_info(steam->hdev, "Steam Controller '%s' connected",
> + steam->serial_no);
> +
> + /* ignore battery errors, we can live without it */
> + if (steam->quirks & STEAM_QUIRK_WIRELESS)
> + steam_battery_register(steam);
> +
> + mutex_lock(&steam_devices_lock);
> + list_add(&steam->list, &steam_devices);
> + mutex_unlock(&steam_devices_lock);
> }
> - if (input) {
> - RCU_INIT_POINTER(steam->input, NULL);
> - synchronize_rcu();
> +
> + mutex_lock(&steam->mutex);
> + if (!steam->client_opened) {
> + steam_set_lizard_mode(steam, lizard_mode);
> + ret = steam_input_register(steam);
> + } else {
> + ret = 0;
> + }
> + mutex_unlock(&steam->mutex);
> +
> + return ret;
> +}
> +
> +static void steam_unregister(struct steam_device *steam)
> +{
> + steam_battery_unregister(steam);
> + steam_input_unregister(steam);
> + if (steam->serial_no[0]) {
> hid_info(steam->hdev, "Steam Controller '%s' disconnected",
> steam->serial_no);
> - input_unregister_device(input);
> + mutex_lock(&steam_devices_lock);
> + list_del(&steam->list);
> + mutex_unlock(&steam_devices_lock);
> + steam->serial_no[0] = 0;
> }
> }
>
> @@ -600,6 +632,9 @@ static int steam_client_ll_open(struct hid_device *hdev)
> mutex_lock(&steam->mutex);
> steam->client_opened = true;
> mutex_unlock(&steam->mutex);
> +
> + steam_input_unregister(steam);
> +
> return ret;
> }
>
> @@ -609,13 +644,13 @@ static void steam_client_ll_close(struct hid_device *hdev)
>
> mutex_lock(&steam->mutex);
> steam->client_opened = false;
> - if (steam->input_opened)
> - steam_set_lizard_mode(steam, false);
> - else
> - steam_set_lizard_mode(steam, lizard_mode);
> mutex_unlock(&steam->mutex);
>
> hid_hw_close(steam->hdev);
> + if (steam->connected) {
> + steam_set_lizard_mode(steam, lizard_mode);
> + steam_input_register(steam);
> + }
> }
>
> static int steam_client_ll_raw_request(struct hid_device *hdev,
> @@ -744,11 +779,6 @@ static int steam_probe(struct hid_device *hdev,
> }
> }
>
> - mutex_lock(&steam_devices_lock);
> - steam_update_lizard_mode(steam);
> - list_add(&steam->list, &steam_devices);
> - mutex_unlock(&steam_devices_lock);
> -
> return 0;
>
> hid_hw_open_fail:
> @@ -774,10 +804,6 @@ static void steam_remove(struct hid_device *hdev)
> return;
> }
>
> - mutex_lock(&steam_devices_lock);
> - list_del(&steam->list);
> - mutex_unlock(&steam_devices_lock);
> -
> hid_destroy_device(steam->client_hdev);
> steam->client_opened = false;
> cancel_work_sync(&steam->work_connect);
> @@ -792,12 +818,14 @@ static void steam_remove(struct hid_device *hdev)
> static void steam_do_connect_event(struct steam_device *steam, bool connected)
> {
> unsigned long flags;
> + bool changed;
>
> spin_lock_irqsave(&steam->lock, flags);
> + changed = steam->connected != connected;
> steam->connected = connected;
> spin_unlock_irqrestore(&steam->lock, flags);
>
> - if (schedule_work(&steam->work_connect) == 0)
> + if (changed && schedule_work(&steam->work_connect) == 0)
> dbg_hid("%s: connected=%d event already queued\n",
> __func__, connected);
> }
> @@ -1019,13 +1047,8 @@ static int steam_raw_event(struct hid_device *hdev,
> return 0;
> rcu_read_lock();
> input = rcu_dereference(steam->input);
> - if (likely(input)) {
> + if (likely(input))
> steam_do_input_event(steam, input, data);
> - } else {
> - dbg_hid("%s: input data without connect event\n",
> - __func__);
> - steam_do_connect_event(steam, true);
> - }
> rcu_read_unlock();
> break;
> case STEAM_EV_CONNECT:
> @@ -1074,7 +1097,10 @@ static int steam_param_set_lizard_mode(const char *val,
>
> mutex_lock(&steam_devices_lock);
> list_for_each_entry(steam, &steam_devices, list) {
> - steam_update_lizard_mode(steam);
> + mutex_lock(&steam->mutex);
> + if (!steam->client_opened)
> + steam_set_lizard_mode(steam, lizard_mode);
> + mutex_unlock(&steam->mutex);
> }
> mutex_unlock(&steam_devices_lock);
> return 0;
>

\
 
 \ /
  Last update: 2018-10-15 22:02    [W:0.057 / U:3.572 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site