Skip to contentSkip to conversation

HID: logitech-dj: issue udev change event on device connection

PATCH Superseded Filipe Laíns 6 participants 13 messages Mar 18, 2020 – Mar 24, 2020 1 message not in the archive

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 HID: logitech-dj: issue udev change event on device connection

As discussed in the mailing list:

Quoted 5 lines

Right now the hid-logitech-dj driver will export one node for each connected device, even when the device is not connected. That causes some trouble because in userspace we don't have have any way to know if the device is connected or not, so when we try to communicate, if the device is disconnected it will fail.

The solution reached to solve this issue is to trigger an udev change event when the device connects, this way userspace can just wait on those connections instead of trying to ping the device.

---
 drivers/hid/hid-logitech-dj.c | 2 ++
 1 file changed, 2 insertions(+)
drivers/hid/hid-logitech-dj.c +2 -0
index 48dff5d6b605..fcd481a0be1f 100644
@@ -1464,6 +1464,8 @@ static int logi_dj_dj_event(struct hid_device *hdev,
 		if (dj_report->report_params[CONNECTION_STATUS_PARAM_STATUS] ==
 		    STATUS_LINKLOSS) {
 			logi_dj_recv_forward_null_report(djrcv_dev, dj_report);
+		} else {
+			kobject_uevent(&hdev->dev.kobj, KOBJ_CHANGE);
 		}
 		break;
 	default:
Signature · 1 line
2.25.1
#1 lore raw
Quoted 32 lines · Filipe Laíns

As discussed in the mailing list:

Quoted 5 lines

Right now the hid-logitech-dj driver will export one node for each connected device, even when the device is not connected. That causes some trouble because in userspace we don't have have any way to know if the device is connected or not, so when we try to communicate, if the device is disconnected it will fail.

The solution reached to solve this issue is to trigger an udev change event when the device connects, this way userspace can just wait on those connections instead of trying to ping the device.

---
 drivers/hid/hid-logitech-dj.c | 2 ++
 1 file changed, 2 insertions(+)
drivers/hid/hid-logitech-dj.c +2 -1
index 48dff5d6b605..fcd481a0be1f 100644
@@ -1464,6 +1464,8 @@ static int logi_dj_dj_event(struct hid_device *hdev,
                if (dj_report->report_params[CONNECTION_STATUS_PARAM_STATUS] ==
                    STATUS_LINKLOSS) {
                        logi_dj_recv_forward_null_report(djrcv_dev, dj_report);
+               } else {
+                       kobject_uevent(&hdev->dev.kobj, KOBJ_CHANGE);
                }
                break;
        default:
--
Quoted 1 line

2.25.1

The problem that will remain here is the transition period for userspace to start to rely upon
this. It will have no idea whether the kernel is expected to send events or not. What do you
think about adding a syfs attribute to indicate that events are being sent? Or something similar?

#2 lore raw

Hi,

Quoted 33 lines · Mario Limonciello
Quoted 32 lines · Filipe Laíns

As discussed in the mailing list:

Quoted 5 lines

Right now the hid-logitech-dj driver will export one node for each connected device, even when the device is not connected. That causes some trouble because in userspace we don't have have any way to know if the device is connected or not, so when we try to communicate, if the device is disconnected it will fail.

The solution reached to solve this issue is to trigger an udev change event when the device connects, this way userspace can just wait on those connections instead of trying to ping the device.

---
  drivers/hid/hid-logitech-dj.c | 2 ++
  1 file changed, 2 insertions(+)
drivers/hid/hid-logitech-dj.c +2 -1
index 48dff5d6b605..fcd481a0be1f 100644
@@ -1464,6 +1464,8 @@ static int logi_dj_dj_event(struct hid_device *hdev,
                 if (dj_report->report_params[CONNECTION_STATUS_PARAM_STATUS] ==
                     STATUS_LINKLOSS) {
                         logi_dj_recv_forward_null_report(djrcv_dev, dj_report);
+               } else {
+                       kobject_uevent(&hdev->dev.kobj, KOBJ_CHANGE);
                 }
                 break;
         default:
--
Quoted 8 lines
Quoted 1 line

2.25.1

The problem that will remain here is the transition period for userspace to start to rely upon
this. It will have no idea whether the kernel is expected to send events or not. What do you
think about adding a syfs attribute to indicate that events are being sent? Or something similar?

Then we would need to support that attribute forever. IMHO the best option is to just make a uname call and check the kernel version, with the code marked to be removed in the future when kernels older then $version are no longer something we want to support.

Regards,

Hans

#3 lore raw
Quoted 45 lines · Hans de Goede

Hi,

Quoted 33 lines · Mario Limonciello
Quoted 32 lines · Filipe Laíns

As discussed in the mailing list:

Quoted 5 lines

Right now the hid-logitech-dj driver will export one node for each connected device, even when the device is not connected. That causes some trouble because in userspace we don't have have any way to know if the device is connected or not, so when we try to communicate, if the device is disconnected it will fail.

The solution reached to solve this issue is to trigger an udev change event when the device connects, this way userspace can just wait on those connections instead of trying to ping the device.

---
  drivers/hid/hid-logitech-dj.c | 2 ++
  1 file changed, 2 insertions(+)
drivers/hid/hid-logitech-dj.c +2 -1
index 48dff5d6b605..fcd481a0be1f 100644
@@ -1464,6 +1464,8 @@ static int logi_dj_dj_event(struct hid_device *hdev,
                 if (dj_report->report_params[CONNECTION_STATUS_PARAM_STATUS] ==
                     STATUS_LINKLOSS) {
                         logi_dj_recv_forward_null_report(djrcv_dev, dj_report);
+               } else {
+                       kobject_uevent(&hdev->dev.kobj, KOBJ_CHANGE);
                 }
                 break;
         default:
--
Quoted 8 lines
Quoted 1 line

2.25.1

The problem that will remain here is the transition period for userspace to start to rely upon
this. It will have no idea whether the kernel is expected to send events or not. What do you
think about adding a syfs attribute to indicate that events are being sent? Or something similar?

Quoted 4 lines

Then we would need to support that attribute forever. IMHO the best option is to just make a uname call and check the kernel version, with the code marked to be removed in the future when kernels older then $version are no longer something we want to support.

Also note that we may not have access to /sys.

Cheers,
Peter

maintainer
#4 lore raw
Quoted 4 lines · Peter Hutterer
Quoted 4 lines

Then we would need to support that attribute forever. IMHO the best option is to just make a uname call and check the kernel version, with the code marked to be removed in the future when kernels older then $version are no longer something we want to support.

Oh, this doesn't work *at all* with distro kernels backporting everything that passess by to kernels with major versions looking years old.

I (as one of the "guilty ones" with my distro hat on) am not at all saying it's perfect, but that's the way it is.

Signature · 2 lines
Jiri Kosina
SUSE Labs

A message that is not in the archive (sent off-list or not yet received): CA+EcB1P0qW4hdWG1YAYkD6X8jL1OaXZn4Lfu7aCmGBqwOPrJyA@mail.gmail.com

#6 lore raw
Quoted 15 lines · Mario Limonciello
Quoted 13 lines · On Fri, Mar 20, 2020, 19:06 Jiri Kosina <[email protected]> wrote:
Quoted 4 lines · Peter Hutterer
Quoted 4 lines

Then we would need to support that attribute forever. IMHO the best option is to just make a uname call and check the kernel version, with the code marked to be removed in the future when kernels older then $version are no longer something we want to support.

Oh, this doesn't work *at all* with distro kernels backporting everything that passess by to kernels with major versions looking years old.

I (as one of the "guilty ones" with my distro hat on) am not at all saying it's perfect, but that's the way it is.

Quoted 8 lines
Quoted 4 lines

--
Jiri Kosina
SUSE Lab

Another "solution" is to use module versioning bump as part of this patch. At least when distros backport then you can look at module versioning to tell the behavior of the driver.

tbh, if there is no good solution in the kernel to communicate this, userspace can make do without knowing about it ahead of time.

long-term you can just assume you'll get the change event and handle the error case just as you'd have to do now. Sure it'd be nice to know ahead of time but it's not the only thing we don't know until we get the first event.

Cheers,
Peter

#7 lore raw
In reply to Filipe Laíns
Quoted 32 lines · Filipe Laíns

As discussed in the mailing list:

Quoted 8 lines

Right now the hid-logitech-dj driver will export one node for each connected device, even when the device is not connected. That causes
some trouble because in userspace we don't have have any way to know if
the device is connected or not, so when we try to communicate, if the
device is disconnected it will fail.

The solution reached to solve this issue is to trigger an udev change event when the device connects, this way userspace can just wait on those connections instead of trying to ping the device.

---
 drivers/hid/hid-logitech-dj.c | 2 ++
 1 file changed, 2 insertions(+)
drivers/hid/hid- renamed from drivers/hid/hid-logitech-dj.c +0 -0

logitech-dj.c
index 48dff5d6b605..fcd481a0be1f 100644

drivers/hid/hid-logitech-dj.c +0 -0
@@ -1464,6 +1464,8 @@ static int logi_dj_dj_event(struct hid_device
 *hdev,
 		if (dj_report-
Quoted 1 line

report_params[CONNECTION_STATUS_PARAM_STATUS] ==

drivers/hid/hid-logitech-dj.c +0 -0
 		    STATUS_LINKLOSS) {
 			logi_dj_recv_forward_null_report(djrcv_dev,

dj_report);

drivers/hid/hid-logitech-dj.c static int logi_dj_dj_event(struct hid_device *hdev, · line 1471

Quoted 5 lines
drivers/hid/hid-logitech-dj.c +2 -0
+		} else {
+			kobject_uevent(&hdev->dev.kobj, KOBJ_CHANGE);
 		}
 		break;
 	default:

Just noticed I was issuing the udev event on the receiver instead of the connected device. I will send a v2.

Filipe Laíns

#8 lore raw

PATCH v2 1/1 HID: logitech-dj: issue udev change event on device connection

In reply to Filipe Laíns

As discussed in the mailing list:

Quoted 5 lines

Right now the hid-logitech-dj driver will export one node for each connected device, even when the device is not connected. That causes some trouble because in userspace we don't have have any way to know if the device is connected or not, so when we try to communicate, if the device is disconnected it will fail.

The solution reached to solve this issue is to trigger an udev change event when the device connects, this way userspace can just wait on those connections instead of trying to ping the device.

---

v2:
- Issue udev change event on the connected hid device, not on the receiver

---
 drivers/hid/hid-logitech-dj.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/hid/hid-logitech-dj.c +6 -1
index 48dff5d6b605..282e57dd467d 100644
@@ -1412,6 +1412,7 @@ static int logi_dj_dj_event(struct hid_device *hdev,
 {
 	struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
 	struct dj_report *dj_report = (struct dj_report *) data;
+	struct dj_device *dj_dev;
 	unsigned long flags;
 
 	/*
@@ -1447,7 +1448,9 @@ static int logi_dj_dj_event(struct hid_device *hdev,
 
 	spin_lock_irqsave(&djrcv_dev->lock, flags);
 
-	if (!djrcv_dev->paired_dj_devices[dj_report->device_index]) {
+	dj_dev = djrcv_dev->paired_dj_devices[dj_report->device_index];
+
+	if (!dj_dev) {
 		/* received an event for an unknown device, bail out */
 		logi_dj_recv_queue_notification(djrcv_dev, dj_report);
 		goto out;
@@ -1464,6 +1467,8 @@ static int logi_dj_dj_event(struct hid_device *hdev,
 		if (dj_report->report_params[CONNECTION_STATUS_PARAM_STATUS] ==
 		    STATUS_LINKLOSS) {
 			logi_dj_recv_forward_null_report(djrcv_dev, dj_report);
+		} else {
+			kobject_uevent(&dj_dev->hdev->dev.kobj, KOBJ_CHANGE);
 		}
 		break;
 	default:
Signature · 1 line
2.25.1
#9 lore raw
Quoted 10 lines · Filipe Laíns

As discussed in the mailing list:

Quoted 8 lines

Right now the hid-logitech-dj driver will export one node for each connected device, even when the device is not connected. That causes
some trouble because in userspace we don't have have any way to know if
the device is connected or not, so when we try to communicate, if the
device is disconnected it will fail.

Why is it a problem that user-space communication fails? Note that sending a signal without any way to fetch the state means that it's always going to be racy.

Quoted 55 lines

The solution reached to solve this issue is to trigger an udev change event when the device connects, this way userspace can just wait on those connections instead of trying to ping the device.

---

v2:
- Issue udev change event on the connected hid device, not on the receiver

---
 drivers/hid/hid-logitech-dj.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/hid/hid- renamed from drivers/hid/hid-logitech-dj.c +0 -0

logitech-dj.c
index 48dff5d6b605..282e57dd467d 100644

drivers/hid/hid-logitech-dj.c +1 -0
@@ -1412,6 +1412,7 @@ static int logi_dj_dj_event(struct hid_device
 *hdev,
 {
 	struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
 	struct dj_report *dj_report = (struct dj_report *) data;
+	struct dj_device *dj_dev;
 	unsigned long flags;
 
drivers/hid/hid-logitech-dj.c +3 -1
 	/*
@@ -1447,7 +1448,9 @@ static int logi_dj_dj_event(struct hid_device
 *hdev,
 
 	spin_lock_irqsave(&djrcv_dev->lock, flags);
 
-	if (!djrcv_dev->paired_dj_devices[dj_report->device_index]) {
+	dj_dev = djrcv_dev->paired_dj_devices[dj_report->device_index];
+
+	if (!dj_dev) {
 		/* received an event for an unknown device, bail out */
 		logi_dj_recv_queue_notification(djrcv_dev, dj_report);
drivers/hid/hid-logitech-dj.c +0 -0
 		goto out;
@@ -1464,6 +1467,8 @@ static int logi_dj_dj_event(struct hid_device
 *hdev,
 		if (dj_report-
Quoted 1 line

report_params[CONNECTION_STATUS_PARAM_STATUS] ==

drivers/hid/hid-logitech-dj.c +0 -0
 		    STATUS_LINKLOSS) {
 			logi_dj_recv_forward_null_report(djrcv_dev,

dj_report);

drivers/hid/hid-logitech-dj.c +2 -0
+		} else {
+			kobject_uevent(&dj_dev->hdev->dev.kobj,

KOBJ_CHANGE);

drivers/hid/hid-logitech-dj.c +0 -0
 		}
 		break;
 	default:
#10 lore raw
Quoted 12 lines · Bastien Nocera
Quoted 10 lines · Filipe Laíns

As discussed in the mailing list:

Quoted 8 lines

Right now the hid-logitech-dj driver will export one node for each connected device, even when the device is not connected. That causes
some trouble because in userspace we don't have have any way to know if
the device is connected or not, so when we try to communicate, if the
device is disconnected it will fail.

Quoted 3 lines

Why is it a problem that user-space communication fails? Note that sending a signal without any way to fetch the state means that it's always going to be racy.

It failing is not the problem. The problem is knowing when the device is available again. Right now the only way to do that is to listen for events or periodically ping it.

We want to only export the HID++ hidraw node when the device is available but that will take a while. We will have to test and sync up userspace. I also want to write tests for the driver before, to make sure there are no regressions. We had a thread discussing this, IIRC you were in CC.

Quoted 55 lines
Quoted 55 lines

The solution reached to solve this issue is to trigger an udev change event when the device connects, this way userspace can just wait on those connections instead of trying to ping the device.

---

v2:
- Issue udev change event on the connected hid device, not on the receiver

---
 drivers/hid/hid-logitech-dj.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/hid/hid- renamed from drivers/hid/hid-logitech-dj.c +0 -0

logitech-dj.c
index 48dff5d6b605..282e57dd467d 100644

drivers/hid/hid-logitech-dj.c +1 -0
@@ -1412,6 +1412,7 @@ static int logi_dj_dj_event(struct hid_device
 *hdev,
 {
 	struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
 	struct dj_report *dj_report = (struct dj_report *) data;
+	struct dj_device *dj_dev;
 	unsigned long flags;
 
drivers/hid/hid-logitech-dj.c +3 -1
 	/*
@@ -1447,7 +1448,9 @@ static int logi_dj_dj_event(struct hid_device
 *hdev,
 
 	spin_lock_irqsave(&djrcv_dev->lock, flags);
 
-	if (!djrcv_dev->paired_dj_devices[dj_report->device_index]) {
+	dj_dev = djrcv_dev->paired_dj_devices[dj_report->device_index];
+
+	if (!dj_dev) {
 		/* received an event for an unknown device, bail out */
 		logi_dj_recv_queue_notification(djrcv_dev, dj_report);
drivers/hid/hid-logitech-dj.c +0 -0
 		goto out;
@@ -1464,6 +1467,8 @@ static int logi_dj_dj_event(struct hid_device
 *hdev,
 		if (dj_report-
Quoted 1 line

report_params[CONNECTION_STATUS_PARAM_STATUS] ==

drivers/hid/hid-logitech-dj.c +0 -0
 		    STATUS_LINKLOSS) {
 			logi_dj_recv_forward_null_report(djrcv_dev,

dj_report);

drivers/hid/hid-logitech-dj.c +2 -0
+		} else {
+			kobject_uevent(&dj_dev->hdev->dev.kobj,

KOBJ_CHANGE);

drivers/hid/hid-logitech-dj.c +0 -0
 		}
 		break;
 	default:
Signature · 1 line
Filipe Laíns
#11 lore raw
Quoted 24 lines · Filipe Laíns
Quoted 14 lines · Bastien Nocera
Quoted 12 lines · Filipe Laíns

As discussed in the mailing list:

Quoted 10 lines

Right now the hid-logitech-dj driver will export one node for each
connected device, even when the device is not connected. That causes
some trouble because in userspace we don't have have any way to know if
the device is connected or not, so when we try to communicate, if
the
device is disconnected it will fail.

Quoted 3 lines

Why is it a problem that user-space communication fails? Note that sending a signal without any way to fetch the state means that it's always going to be racy.

It failing is not the problem. The problem is knowing when the device is available again. Right now the only way to do that is to listen for
events or periodically ping it.

Quoted 6 lines

We want to only export the HID++ hidraw node when the device is available but that will take a while. We will have to test and sync up
userspace. I also want to write tests for the driver before, to make sure there are no regressions. We had a thread discussing this, IIRC you were in CC.

If I need to remember some old thread to know what we're talking about, then that means that the commit message is probably not good enough...

Please add some links to the relevant discussion on bug forums if there's interesting data there too.

Quoted 62 lines
Quoted 62 lines
Quoted 62 lines

The solution reached to solve this issue is to trigger an udev change
event when the device connects, this way userspace can just wait on
those connections instead of trying to ping the device.

---

v2:
- Issue udev change event on the connected hid device, not on
the
receiver

---
 drivers/hid/hid-logitech-dj.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/hid/hid- renamed from drivers/hid/hid-logitech-dj.c +0 -0

logitech-dj.c
index 48dff5d6b605..282e57dd467d 100644

drivers/hid/hid-logitech-dj.c +0 -0
@@ -1412,6 +1412,7 @@ static int logi_dj_dj_event(struct

hid_device
*hdev,
{

drivers/hid/hid-logitech-dj.c +1 -0
 	struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
 	struct dj_report *dj_report = (struct dj_report *) data;
+	struct dj_device *dj_dev;
 	unsigned long flags;
 
 	/*
@@ -1447,7 +1448,9 @@ static int logi_dj_dj_event(struct

hid_device
*hdev,

drivers/hid/hid-logitech-dj.c +3 -1
 	spin_lock_irqsave(&djrcv_dev->lock, flags);
 
-	if (!djrcv_dev->paired_dj_devices[dj_report->device_index]) {
+	dj_dev = djrcv_dev->paired_dj_devices[dj_report->device_index];
+
+	if (!dj_dev) {
 		/* received an event for an unknown device, bail out */
 		logi_dj_recv_queue_notification(djrcv_dev, dj_report);
 		goto out;
@@ -1464,6 +1467,8 @@ static int logi_dj_dj_event(struct

hid_device
*hdev,
if (dj_report-

Quoted 1 line

report_params[CONNECTION_STATUS_PARAM_STATUS] ==

drivers/hid/hid-logitech-dj.c +0 -0
 		    STATUS_LINKLOSS) {
 			logi_dj_recv_forward_null_report(djrcv_dev,

dj_report);

drivers/hid/hid-logitech-dj.c +2 -0
+		} else {
+			kobject_uevent(&dj_dev->hdev->dev.kobj,

KOBJ_CHANGE);

drivers/hid/hid-logitech-dj.c +0 -0
 		}
 		break;
 	default:
#12 lore raw
Quoted 32 lines · Bastien Nocera
Quoted 24 lines · Filipe Laíns
Quoted 14 lines · Bastien Nocera
Quoted 12 lines · Filipe Laíns

As discussed in the mailing list:

Quoted 10 lines

Right now the hid-logitech-dj driver will export one node for each
connected device, even when the device is not connected. That causes
some trouble because in userspace we don't have have any way to know if
the device is connected or not, so when we try to communicate, if
the
device is disconnected it will fail.

Quoted 3 lines

Why is it a problem that user-space communication fails? Note that sending a signal without any way to fetch the state means that it's always going to be racy.

It failing is not the problem. The problem is knowing when the device is available again. Right now the only way to do that is to listen for
events or periodically ping it.

Quoted 6 lines

We want to only export the HID++ hidraw node when the device is available but that will take a while. We will have to test and sync up
userspace. I also want to write tests for the driver before, to make sure there are no regressions. We had a thread discussing this, IIRC you were in CC.

Quoted 2 lines

If I need to remember some old thread to know what we're talking about, then that means that the commit message is probably not good enough...

Should I put in the commit message what is planned next?

Quoted 2 lines

Please add some links to the relevant discussion on bug forums if there's interesting data there too.

You can find the discussion in [1][2].

[1] https://www.spinics.net/lists/linux-input/thrd2.html#65615
[2] https://www.spinics.net/lists/linux-input/msg65615.html

Quoted 61 lines
Quoted 61 lines
Quoted 61 lines
Quoted 61 lines

The solution reached to solve this issue is to trigger an udev change
event when the device connects, this way userspace can just wait on
those connections instead of trying to ping the device.

---

v2:
- Issue udev change event on the connected hid device, not on
the
receiver

---
 drivers/hid/hid-logitech-dj.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/hid/hid- renamed from drivers/hid/hid-logitech-dj.c +0 -0

logitech-dj.c
index 48dff5d6b605..282e57dd467d 100644

drivers/hid/hid-logitech-dj.c +0 -0
@@ -1412,6 +1412,7 @@ static int logi_dj_dj_event(struct

hid_device
*hdev,
{

drivers/hid/hid-logitech-dj.c +1 -0
 	struct dj_receiver_dev *djrcv_dev = hid_get_drvdata(hdev);
 	struct dj_report *dj_report = (struct dj_report *) data;
+	struct dj_device *dj_dev;
 	unsigned long flags;
 
 	/*
@@ -1447,7 +1448,9 @@ static int logi_dj_dj_event(struct

hid_device
*hdev,

drivers/hid/hid-logitech-dj.c +3 -1
 	spin_lock_irqsave(&djrcv_dev->lock, flags);
 
-	if (!djrcv_dev->paired_dj_devices[dj_report->device_index]) {
+	dj_dev = djrcv_dev->paired_dj_devices[dj_report->device_index];
+
+	if (!dj_dev) {
 		/* received an event for an unknown device, bail out */
 		logi_dj_recv_queue_notification(djrcv_dev, dj_report);
 		goto out;
@@ -1464,6 +1467,8 @@ static int logi_dj_dj_event(struct

hid_device
*hdev,
if (dj_report-

Quoted 1 line

report_params[CONNECTION_STATUS_PARAM_STATUS] ==

drivers/hid/hid-logitech-dj.c +0 -0
 		    STATUS_LINKLOSS) {
 			logi_dj_recv_forward_null_report(djrcv_dev,

dj_report);

drivers/hid/hid-logitech-dj.c +2 -0
+		} else {
+			kobject_uevent(&dj_dev->hdev->dev.kobj,

KOBJ_CHANGE);

drivers/hid/hid-logitech-dj.c +0 -0
 		}
 		break;
 	default:
Signature · 1 line
Filipe Laíns
#13 lore raw
Quoted 44 lines · Filipe Laíns
Quoted 43 lines · Bastien Nocera
Quoted 41 lines · Filipe Laíns
Quoted 18 lines · Bastien Nocera
Quoted 16 lines · Filipe Laíns

As discussed in the mailing list:

Quoted 14 lines

Right now the hid-logitech-dj driver will export one node for
each
connected device, even when the device is not connected. That
causes
some trouble because in userspace we don't have have any way to
know if
the device is connected or not, so when we try to communicate,
if
the
device is disconnected it will fail.

Quoted 5 lines

Why is it a problem that user-space communication fails? Note that
sending a signal without any way to fetch the state means that it's
always going to be racy.

It failing is not the problem. The problem is knowing when the device
is available again. Right now the only way to do that is to listen
for
events or periodically ping it.

We want to only export the HID++ hidraw node when the device is available but that will take a while. We will have to test and sync
up
userspace. I also want to write tests for the driver before, to make
sure there are no regressions. We had a thread discussing this, IIRC
you were in CC.

Quoted 6 lines
Quoted 4 lines

If I need to remember some old thread to know what we're talking about,
then that means that the commit message is probably not good enough...

Should I put in the commit message what is planned next?

You should put in everything that explains why this change is needed, and how user-space is supposed to use that information. Nobody should have to refer back to the mailing-list thread to find this out.

Quoted 7 lines
Quoted 2 lines

Please add some links to the relevant discussion on bug forums if there's interesting data there too.

You can find the discussion in [1][2].

[1] https://www.spinics.net/lists/linux-input/thrd2.html#65615
[2] https://www.spinics.net/lists/linux-input/msg65615.html

I was in CC: because "might be maintaining one of the affected userspace stacks", but I don't know what that stack might be for me. Is it for upower (which I only work on seldom and definitely don't maintain), or something else?

Quoted 71 lines
Quoted 71 lines
Quoted 71 lines
Quoted 71 lines
Quoted 71 lines

The solution reached to solve this issue is to trigger an udev
change
event when the device connects, this way userspace can just wait
on
those connections instead of trying to ping the device.

---

v2:
- Issue udev change event on the connected hid device, not
on
the
receiver

---
 drivers/hid/hid-logitech-dj.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)
drivers/hid/hid- renamed from drivers/hid/hid-logitech-dj.c +0 -0

logitech-dj.c
index 48dff5d6b605..282e57dd467d 100644

drivers/hid/hid-logitech-dj.c +0 -0
@@ -1412,6 +1412,7 @@ static int logi_dj_dj_event(struct

hid_device
*hdev,
{
struct dj_receiver_dev *djrcv_dev =
hid_get_drvdata(hdev);
struct dj_report *dj_report = (struct dj_report *)
data;

drivers/hid/hid-logitech-dj.c +1 -0
+	struct dj_device *dj_dev;
 	unsigned long flags;
 
 	/*
@@ -1447,7 +1448,9 @@ static int logi_dj_dj_event(struct

hid_device
*hdev,

drivers/hid/hid-logitech-dj.c +0 -1
 	spin_lock_irqsave(&djrcv_dev->lock, flags);
 
-	if (!djrcv_dev->paired_dj_devices[dj_report-
Quoted 1 line

device_index]) {

drivers/hid/hid-logitech-dj.c +1 -0
+	dj_dev = djrcv_dev->paired_dj_devices[dj_report-
Quoted 1 line

device_index];

drivers/hid/hid-logitech-dj.c +2 -0
+
+	if (!dj_dev) {
 		/* received an event for an unknown device,

bail out */
logi_dj_recv_queue_notification(djrcv_dev,
dj_report);

drivers/hid/hid-logitech-dj.c +0 -0
 		goto out;
@@ -1464,6 +1467,8 @@ static int logi_dj_dj_event(struct

hid_device
*hdev,
if (dj_report-

Quoted 1 line

report_params[CONNECTION_STATUS_PARAM_STATUS] ==

drivers/hid/hid-logitech-dj.c +0 -0
 		    STATUS_LINKLOSS) {
 			logi_dj_recv_forward_null_report(djrcv_

dev,
dj_report);

drivers/hid/hid-logitech-dj.c +2 -0
+		} else {
+			kobject_uevent(&dj_dev->hdev->dev.kobj,

KOBJ_CHANGE);

drivers/hid/hid-logitech-dj.c +0 -0
 		}
 		break;
 	default: