wacom_remote_status_irq() sends information of addition/removal of EKR.
We want to allocate one input node per remote, so better having this
in a separate worker, not handled in the IRQ directly.
Signed-off-by: Benjamin Tissoires <benjamin.tissoi...@redhat.com>
Acked-by: Ping Cheng <pi...@wacom.com>
Signed-off-by: Jiri Kosina <jkos...@suse.cz>
[aaron.sko...@wacom.com: Imported into input-wacom repository (e6f2813)]
Signed-off-by: Aaron Armstrong Skomra <aaron.sko...@wacom.com>
[aaron.sko...@wacom.com: Backported from input-wacom repository (0cf7522)]
Signed-off-by: Aaron Armstrong Skomra <aaron.sko...@wacom.com>
---
2.6.38/wacom.h | 11 ++++++--
2.6.38/wacom_sys.c | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++--
2.6.38/wacom_wac.c | 54 +++++++++++++++---------------------
2.6.38/wacom_wac.h | 7 +++++
3.17/wacom.h | 11 ++++++--
3.17/wacom_sys.c | 80 ++++++++++++++++++++++++++++++++++++++++++++++++++++--
3.17/wacom_wac.c | 53 ++++++++++++++----------------------
3.17/wacom_wac.h | 7 +++++
3.7/wacom.h | 11 ++++++--
3.7/wacom_sys.c | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++--
3.7/wacom_wac.c | 54 +++++++++++++++---------------------
3.7/wacom_wac.h | 7 +++++
12 files changed, 341 insertions(+), 112 deletions(-)
diff --git a/2.6.38/wacom.h b/2.6.38/wacom.h
index c8941c9..b4470b3 100644
--- a/2.6.38/wacom.h
+++ b/2.6.38/wacom.h
@@ -87,6 +87,7 @@
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/init.h>
+#include <linux/kfifo.h>
#include <linux/usb/input.h>
#include <linux/power_supply.h>
#include <asm/unaligned.h>
@@ -115,6 +116,7 @@ MODULE_LICENSE(DRIVER_LICENSE);
enum wacom_worker {
WACOM_WORKER_WIRELESS,
WACOM_WORKER_BATTERY,
+ WACOM_WORKER_REMOTE,
};
struct wacom {
@@ -126,6 +128,9 @@ struct wacom {
struct mutex lock;
struct work_struct wireless_work;
struct work_struct battery_work;
+ struct work_struct remote_work;
+ spinlock_t remote_lock;
+ struct kfifo remote_fifo;
bool open;
char phys[32];
struct wacom_led {
@@ -151,6 +156,9 @@ static inline void wacom_schedule_work(struct wacom_wac
*wacom_wac,
case WACOM_WORKER_BATTERY:
schedule_work(&wacom->battery_work);
break;
+ case WACOM_WORKER_REMOTE:
+ schedule_work(&wacom->remote_work);
+ break;
}
}
@@ -161,7 +169,4 @@ void wacom_setup_device_quirks(struct wacom *wacom);
int wacom_setup_input_capabilities(struct input_dev *input_dev,
struct wacom_wac *wacom_wac);
void wacom_battery_work(struct work_struct *work);
-int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial,
- int index);
-void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial);
#endif
diff --git a/2.6.38/wacom_sys.c b/2.6.38/wacom_sys.c
index 2ef93fc..12a3c66 100644
--- a/2.6.38/wacom_sys.c
+++ b/2.6.38/wacom_sys.c
@@ -1272,7 +1272,7 @@ DEVICE_EKR_ATTR_GROUP(2);
DEVICE_EKR_ATTR_GROUP(3);
DEVICE_EKR_ATTR_GROUP(4);
-int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial, int
index)
+static int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial,
int index)
{
int error = 0;
char *buf;
@@ -1297,7 +1297,7 @@ int wacom_remote_create_attr_group(struct wacom *wacom,
__u32 serial, int index)
return 0;
}
-void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial)
+static void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial)
{
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
int i;
@@ -1613,6 +1613,66 @@ void wacom_battery_work(struct work_struct *work)
}
}
+static void wacom_remote_work(struct work_struct *work)
+{
+ struct wacom *wacom = container_of(work, struct wacom, remote_work);
+ struct device *dev = &wacom->intf->dev;
+ struct wacom_wac *wacom_wac = &wacom->wacom_wac;
+ struct wacom_remote_data data;
+ unsigned long flags;
+ unsigned int count;
+ u32 serial;
+ int i, k;
+
+ spin_lock_irqsave(&wacom->remote_lock, flags);
+
+ count = kfifo_out(&wacom->remote_fifo, &data, sizeof(data));
+
+ if (count != sizeof(data)) {
+ dev_err(dev,
+ "workitem triggered without status available\n");
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+ return;
+ }
+
+ if (!kfifo_is_empty(&wacom->remote_fifo))
+ wacom_schedule_work(&wacom->wacom_wac, WACOM_WORKER_REMOTE);
+
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+
+ for (i = 0; i < WACOM_MAX_REMOTES; i++) {
+ serial = data.remote[i].serial;
+ if (data.remote[i].connected) {
+
+ if (wacom_wac->serial[i] == serial)
+ continue;
+
+ if (wacom_wac->serial[i]) {
+ wacom_remote_destroy_attr_group(wacom,
+ wacom_wac->serial[i]);
+ }
+
+ /* A remote can pair more than once with an EKR,
+ * check to make sure this serial isn't already paired.
+ */
+ for (k = 0; k < WACOM_MAX_REMOTES; k++) {
+ if (wacom_wac->serial[k] == serial)
+ break;
+ }
+
+ if (k < WACOM_MAX_REMOTES) {
+ wacom_wac->serial[i] = serial;
+ continue;
+ }
+ wacom_remote_create_attr_group(wacom, serial, i);
+
+ } else if (wacom_wac->serial[i]) {
+ wacom_remote_destroy_attr_group(wacom,
+ wacom_wac->serial[i]);
+ }
+ }
+}
+
static int wacom_probe(struct usb_interface *intf, const struct usb_device_id
*id)
{
struct usb_device *dev = interface_to_usbdev(intf);
@@ -1660,6 +1720,18 @@ static int wacom_probe(struct usb_interface *intf, const
struct usb_device_id *i
mutex_init(&wacom->lock);
INIT_WORK(&wacom->wireless_work, wacom_wireless_work);
INIT_WORK(&wacom->battery_work, wacom_battery_work);
+ INIT_WORK(&wacom->remote_work, wacom_remote_work);
+ spin_lock_init(&wacom->remote_lock);
+
+ if (kfifo_alloc(&wacom->remote_fifo,
+ 5 * sizeof(struct wacom_remote_data),
+ GFP_KERNEL)) {
+ dev_err(&wacom->intf->dev,
+ "%s:failed allocating remote_fifo\n", __func__);
+ error = -ENOMEM;
+ goto fail2;
+ }
+
usb_make_path(dev, wacom->phys, sizeof(wacom->phys));
strlcat(wacom->phys, "/input0", sizeof(wacom->phys));
@@ -1742,6 +1814,7 @@ static int wacom_probe(struct usb_interface *intf, const
struct usb_device_id *i
fail4: wacom_remove_shared_data(wacom_wac);
fail3: usb_free_urb(wacom->irq);
wacom_destroy_battery(wacom);
+ kfifo_free(&wacom->remote_fifo);
fail2: usb_free_coherent(dev, WACOM_PKGLEN_MAX, wacom_wac->data,
wacom->data_dma);
fail1:
return error;
@@ -1757,6 +1830,8 @@ static void wacom_disconnect(struct usb_interface *intf)
usb_kill_urb(wacom->irq);
cancel_work_sync(&wacom->wireless_work);
cancel_work_sync(&wacom->battery_work);
+ cancel_work_sync(&wacom->remote_work);
+ kfifo_free(&wacom->remote_fifo);
for (i = 0; i < WACOM_MAX_REMOTES; i++) {
if (wacom->remote_group[i].name) {
wacom_remote_destroy_attr_group(wacom,
diff --git a/2.6.38/wacom_wac.c b/2.6.38/wacom_wac.c
index b131855..4361d55 100644
--- a/2.6.38/wacom_wac.c
+++ b/2.6.38/wacom_wac.c
@@ -770,52 +770,41 @@ static int wacom_remote_irq(struct wacom_wac *wacom_wac,
size_t len)
return 1;
}
-static int wacom_remote_status_irq(struct wacom_wac *wacom_wac, size_t len)
+static void wacom_remote_status_irq(struct wacom_wac *wacom_wac, size_t len)
{
struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
+ struct device *dev = &wacom->intf->dev;
unsigned char *data = wacom_wac->data;
- int i;
+ struct wacom_remote_data remote_data;
+ unsigned long flags;
+ int i, ret;
if (data[0] != WACOM_REPORT_DEVICE_LIST)
- return 0;
+ return;
+
+ memset(&remote_data, 0, sizeof(struct wacom_remote_data));
for (i = 0; i < WACOM_MAX_REMOTES; i++) {
int j = i * 6;
int serial = (data[j+6] << 16) + (data[j+5] << 8) + data[j+4];
bool connected = data[j+2];
- if (connected) {
- int k;
-
- if (wacom_wac->serial[i] == serial)
- continue;
-
- if (wacom_wac->serial[i]) {
- wacom_remote_destroy_attr_group(wacom,
- wacom_wac->serial[i]);
- }
-
- /* A remote can pair more than once with an EKR,
- * check to make sure this serial isn't already paired.
- */
- for (k = 0; k < WACOM_MAX_REMOTES; k++) {
- if (wacom_wac->serial[k] == serial)
- break;
- }
+ remote_data.remote[i].serial = serial;
+ remote_data.remote[i].connected = connected;
+ }
- if (k < WACOM_MAX_REMOTES) {
- wacom_wac->serial[i] = serial;
- continue;
- }
- wacom_remote_create_attr_group(wacom, serial, i);
+ spin_lock_irqsave(&wacom->remote_lock, flags);
- } else if (wacom_wac->serial[i]) {
- wacom_remote_destroy_attr_group(wacom,
- wacom_wac->serial[i]);
- }
+ ret = kfifo_in(&wacom->remote_fifo, &remote_data, sizeof(remote_data));
+ if (ret != sizeof(remote_data)) {
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+ dev_err(dev, "Can't queue Remote status event.\n");
+ return;
}
- return 0;
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+
+ wacom_schedule_work(wacom_wac, WACOM_WORKER_REMOTE);
}
static int wacom_intuos_general(struct wacom_wac *wacom)
@@ -1721,8 +1710,9 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t
len)
break;
case REMOTE:
+ sync = false;
if (wacom_wac->data[0] == WACOM_REPORT_DEVICE_LIST)
- sync = wacom_remote_status_irq(wacom_wac, len);
+ wacom_remote_status_irq(wacom_wac, len);
else
sync = wacom_remote_irq(wacom_wac, len);
break;
diff --git a/2.6.38/wacom_wac.h b/2.6.38/wacom_wac.h
index f8c2fe2..17ca409 100644
--- a/2.6.38/wacom_wac.h
+++ b/2.6.38/wacom_wac.h
@@ -165,6 +165,13 @@ struct wacom_shared {
struct input_dev *touch_input;
};
+struct wacom_remote_data {
+ struct {
+ u32 serial;
+ bool connected;
+ } remote[WACOM_MAX_REMOTES];
+};
+
struct wacom_wac {
char name[WACOM_NAME_MAX];
char bat_name[WACOM_NAME_MAX];
diff --git a/3.17/wacom.h b/3.17/wacom.h
index e7b05da..6b7032f 100644
--- a/3.17/wacom.h
+++ b/3.17/wacom.h
@@ -90,6 +90,7 @@
#include <linux/module.h>
#include <linux/mod_devicetable.h>
#include <linux/hid.h>
+#include <linux/kfifo.h>
#include <linux/usb/input.h>
#include <linux/power_supply.h>
#include <asm/unaligned.h>
@@ -122,6 +123,7 @@
enum wacom_worker {
WACOM_WORKER_WIRELESS,
WACOM_WORKER_BATTERY,
+ WACOM_WORKER_REMOTE,
};
struct wacom_group_leds {
@@ -136,6 +138,9 @@ struct wacom {
struct mutex lock;
struct work_struct wireless_work;
struct work_struct battery_work;
+ struct work_struct remote_work;
+ spinlock_t remote_lock;
+ struct kfifo remote_fifo;
struct wacom_leds {
struct wacom_group_leds *groups;
u8 llv; /* status led brightness no button (1..127) */
@@ -168,6 +173,9 @@ static inline void wacom_schedule_work(struct wacom_wac
*wacom_wac,
case WACOM_WORKER_BATTERY:
schedule_work(&wacom->battery_work);
break;
+ case WACOM_WORKER_REMOTE:
+ schedule_work(&wacom->remote_work);
+ break;
}
}
@@ -187,9 +195,6 @@ int wacom_wac_event(struct hid_device *hdev, struct
hid_field *field,
struct hid_usage *usage, __s32 value);
void wacom_wac_report(struct hid_device *hdev, struct hid_report *report);
void wacom_battery_work(struct work_struct *work);
-int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial,
- int index);
-void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial);
#if LINUX_VERSION_CODE < KERNEL_VERSION(3,19,0)
static int wacom_hid_report_len(struct hid_report *report)
diff --git a/3.17/wacom_sys.c b/3.17/wacom_sys.c
index a899cf2..696efa5 100644
--- a/3.17/wacom_sys.c
+++ b/3.17/wacom_sys.c
@@ -1346,7 +1346,8 @@ DEVICE_EKR_ATTR_GROUP(2);
DEVICE_EKR_ATTR_GROUP(3);
DEVICE_EKR_ATTR_GROUP(4);
-int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial, int
index)
+static int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial,
+ int index)
{
int error = 0;
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
@@ -1370,7 +1371,7 @@ int wacom_remote_create_attr_group(struct wacom *wacom,
__u32 serial, int index)
return 0;
}
-void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial)
+static void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial)
{
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
int i;
@@ -1952,6 +1953,65 @@ fail:
return;
}
+static void wacom_remote_work(struct work_struct *work)
+{
+ struct wacom *wacom = container_of(work, struct wacom, remote_work);
+ struct wacom_wac *wacom_wac = &wacom->wacom_wac;
+ struct wacom_remote_data data;
+ unsigned long flags;
+ unsigned int count;
+ u32 serial;
+ int i, k;
+
+ spin_lock_irqsave(&wacom->remote_lock, flags);
+
+ count = kfifo_out(&wacom->remote_fifo, &data, sizeof(data));
+
+ if (count != sizeof(data)) {
+ hid_err(wacom->hdev,
+ "workitem triggered without status available\n");
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+ return;
+ }
+
+ if (!kfifo_is_empty(&wacom->remote_fifo))
+ wacom_schedule_work(&wacom->wacom_wac, WACOM_WORKER_REMOTE);
+
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+
+ for (i = 0; i < WACOM_MAX_REMOTES; i++) {
+ serial = data.remote[i].serial;
+ if (data.remote[i].connected) {
+
+ if (wacom_wac->serial[i] == serial)
+ continue;
+
+ if (wacom_wac->serial[i]) {
+ wacom_remote_destroy_attr_group(wacom,
+ wacom_wac->serial[i]);
+ }
+
+ /* A remote can pair more than once with an EKR,
+ * check to make sure this serial isn't already paired.
+ */
+ for (k = 0; k < WACOM_MAX_REMOTES; k++) {
+ if (wacom_wac->serial[k] == serial)
+ break;
+ }
+
+ if (k < WACOM_MAX_REMOTES) {
+ wacom_wac->serial[i] = serial;
+ continue;
+ }
+ wacom_remote_create_attr_group(wacom, serial, i);
+
+ } else if (wacom_wac->serial[i]) {
+ wacom_remote_destroy_attr_group(wacom,
+ wacom_wac->serial[i]);
+ }
+ }
+}
+
static int wacom_probe(struct hid_device *hdev,
const struct hid_device_id *id)
{
@@ -1994,6 +2054,17 @@ static int wacom_probe(struct hid_device *hdev,
mutex_init(&wacom->lock);
INIT_WORK(&wacom->wireless_work, wacom_wireless_work);
INIT_WORK(&wacom->battery_work, wacom_battery_work);
+ INIT_WORK(&wacom->remote_work, wacom_remote_work);
+ spin_lock_init(&wacom->remote_lock);
+
+ if (kfifo_alloc(&wacom->remote_fifo,
+ 5 * sizeof(struct wacom_remote_data),
+ GFP_KERNEL)) {
+ dev_err(&hdev->dev,
+ "%s:failed allocating remote_fifo\n", __func__);
+ error = -ENOMEM;
+ goto fail_type;
+ }
/* ask for the report descriptor to be loaded by HID */
error = hid_parse(hdev);
@@ -2016,8 +2087,9 @@ static int wacom_probe(struct hid_device *hdev,
return 0;
-fail_type:
fail_parse:
+ kfifo_free(&wacom->remote_fifo);
+fail_type:
hid_set_drvdata(hdev, NULL);
return error;
}
@@ -2035,6 +2107,8 @@ static void wacom_remove(struct hid_device *hdev)
cancel_work_sync(&wacom->wireless_work);
cancel_work_sync(&wacom->battery_work);
+ cancel_work_sync(&wacom->remote_work);
+ kfifo_free(&wacom->remote_fifo);
kobject_put(wacom->remote_dir);
if (hdev->bus == BUS_BLUETOOTH)
device_remove_file(&hdev->dev, &dev_attr_speed);
diff --git a/3.17/wacom_wac.c b/3.17/wacom_wac.c
index 51dec4a..298d5b3 100644
--- a/3.17/wacom_wac.c
+++ b/3.17/wacom_wac.c
@@ -829,52 +829,40 @@ static int wacom_remote_irq(struct wacom_wac *wacom_wac,
size_t len)
return 1;
}
-static int wacom_remote_status_irq(struct wacom_wac *wacom_wac, size_t len)
+static void wacom_remote_status_irq(struct wacom_wac *wacom_wac, size_t len)
{
struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
unsigned char *data = wacom_wac->data;
- int i;
+ struct wacom_remote_data remote_data;
+ unsigned long flags;
+ int i, ret;
if (data[0] != WACOM_REPORT_DEVICE_LIST)
- return 0;
+ return;
+
+ memset(&remote_data, 0, sizeof(struct wacom_remote_data));
for (i = 0; i < WACOM_MAX_REMOTES; i++) {
int j = i * 6;
int serial = (data[j+6] << 16) + (data[j+5] << 8) + data[j+4];
bool connected = data[j+2];
- if (connected) {
- int k;
-
- if (wacom_wac->serial[i] == serial)
- continue;
-
- if (wacom_wac->serial[i]) {
- wacom_remote_destroy_attr_group(wacom,
- wacom_wac->serial[i]);
- }
-
- /* A remote can pair more than once with an EKR,
- * check to make sure this serial isn't already paired.
- */
- for (k = 0; k < WACOM_MAX_REMOTES; k++) {
- if (wacom_wac->serial[k] == serial)
- break;
- }
+ remote_data.remote[i].serial = serial;
+ remote_data.remote[i].connected = connected;
+ }
- if (k < WACOM_MAX_REMOTES) {
- wacom_wac->serial[i] = serial;
- continue;
- }
- wacom_remote_create_attr_group(wacom, serial, i);
+ spin_lock_irqsave(&wacom->remote_lock, flags);
- } else if (wacom_wac->serial[i]) {
- wacom_remote_destroy_attr_group(wacom,
- wacom_wac->serial[i]);
- }
+ ret = kfifo_in(&wacom->remote_fifo, &remote_data, sizeof(remote_data));
+ if (ret != sizeof(remote_data)) {
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+ hid_err(wacom->hdev, "Can't queue Remote status event.\n");
+ return;
}
- return 0;
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+
+ wacom_schedule_work(wacom_wac, WACOM_WORKER_REMOTE);
}
static int wacom_intuos_general(struct wacom_wac *wacom)
@@ -2316,8 +2304,9 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t
len)
break;
case REMOTE:
+ sync = false;
if (wacom_wac->data[0] == WACOM_REPORT_DEVICE_LIST)
- sync = wacom_remote_status_irq(wacom_wac, len);
+ wacom_remote_status_irq(wacom_wac, len);
else
sync = wacom_remote_irq(wacom_wac, len);
break;
diff --git a/3.17/wacom_wac.h b/3.17/wacom_wac.h
index feeb96d..d05daed 100644
--- a/3.17/wacom_wac.h
+++ b/3.17/wacom_wac.h
@@ -218,6 +218,13 @@ struct hid_data {
int num_received;
};
+struct wacom_remote_data {
+ struct {
+ u32 serial;
+ bool connected;
+ } remote[WACOM_MAX_REMOTES];
+};
+
struct wacom_wac {
char pen_name[WACOM_NAME_MAX];
char touch_name[WACOM_NAME_MAX];
diff --git a/3.7/wacom.h b/3.7/wacom.h
index 1666882..5d4361c 100644
--- a/3.7/wacom.h
+++ b/3.7/wacom.h
@@ -86,6 +86,7 @@
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/mod_devicetable.h>
+#include <linux/kfifo.h>
#include <linux/usb/input.h>
#include <linux/power_supply.h>
#include <asm/unaligned.h>
@@ -111,6 +112,7 @@ MODULE_LICENSE(DRIVER_LICENSE);
enum wacom_worker {
WACOM_WORKER_WIRELESS,
WACOM_WORKER_BATTERY,
+ WACOM_WORKER_REMOTE,
};
struct wacom {
@@ -122,6 +124,9 @@ struct wacom {
struct mutex lock;
struct work_struct wireless_work;
struct work_struct battery_work;
+ struct work_struct remote_work;
+ spinlock_t remote_lock;
+ struct kfifo remote_fifo;
bool open;
char phys[32];
struct wacom_led {
@@ -147,6 +152,9 @@ static inline void wacom_schedule_work(struct wacom_wac
*wacom_wac,
case WACOM_WORKER_BATTERY:
schedule_work(&wacom->battery_work);
break;
+ case WACOM_WORKER_REMOTE:
+ schedule_work(&wacom->remote_work);
+ break;
}
}
@@ -157,7 +165,4 @@ void wacom_setup_device_quirks(struct wacom *wacom);
int wacom_setup_input_capabilities(struct input_dev *input_dev,
struct wacom_wac *wacom_wac);
void wacom_battery_work(struct work_struct *work);
-int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial,
- int index);
-void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial);
#endif
diff --git a/3.7/wacom_sys.c b/3.7/wacom_sys.c
index d264c62..7afa189 100644
--- a/3.7/wacom_sys.c
+++ b/3.7/wacom_sys.c
@@ -1265,7 +1265,7 @@ DEVICE_EKR_ATTR_GROUP(2);
DEVICE_EKR_ATTR_GROUP(3);
DEVICE_EKR_ATTR_GROUP(4);
-int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial, int
index)
+static int wacom_remote_create_attr_group(struct wacom *wacom, __u32 serial,
int index)
{
int error = 0;
char *buf;
@@ -1290,7 +1290,7 @@ int wacom_remote_create_attr_group(struct wacom *wacom,
__u32 serial, int index)
return 0;
}
-void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial)
+static void wacom_remote_destroy_attr_group(struct wacom *wacom, __u32 serial)
{
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
int i;
@@ -1609,6 +1609,66 @@ void wacom_battery_work(struct work_struct *work)
}
}
+static void wacom_remote_work(struct work_struct *work)
+{
+ struct wacom *wacom = container_of(work, struct wacom, remote_work);
+ struct device *dev = &wacom->intf->dev;
+ struct wacom_wac *wacom_wac = &wacom->wacom_wac;
+ struct wacom_remote_data data;
+ unsigned long flags;
+ unsigned int count;
+ u32 serial;
+ int i, k;
+
+ spin_lock_irqsave(&wacom->remote_lock, flags);
+
+ count = kfifo_out(&wacom->remote_fifo, &data, sizeof(data));
+
+ if (count != sizeof(data)) {
+ dev_err(dev,
+ "workitem triggered without status available\n");
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+ return;
+ }
+
+ if (!kfifo_is_empty(&wacom->remote_fifo))
+ wacom_schedule_work(&wacom->wacom_wac, WACOM_WORKER_REMOTE);
+
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+
+ for (i = 0; i < WACOM_MAX_REMOTES; i++) {
+ serial = data.remote[i].serial;
+ if (data.remote[i].connected) {
+
+ if (wacom_wac->serial[i] == serial)
+ continue;
+
+ if (wacom_wac->serial[i]) {
+ wacom_remote_destroy_attr_group(wacom,
+ wacom_wac->serial[i]);
+ }
+
+ /* A remote can pair more than once with an EKR,
+ * check to make sure this serial isn't already paired.
+ */
+ for (k = 0; k < WACOM_MAX_REMOTES; k++) {
+ if (wacom_wac->serial[k] == serial)
+ break;
+ }
+
+ if (k < WACOM_MAX_REMOTES) {
+ wacom_wac->serial[i] = serial;
+ continue;
+ }
+ wacom_remote_create_attr_group(wacom, serial, i);
+
+ } else if (wacom_wac->serial[i]) {
+ wacom_remote_destroy_attr_group(wacom,
+ wacom_wac->serial[i]);
+ }
+ }
+}
+
static int wacom_probe(struct usb_interface *intf, const struct usb_device_id
*id)
{
struct usb_device *dev = interface_to_usbdev(intf);
@@ -1656,6 +1716,18 @@ static int wacom_probe(struct usb_interface *intf, const
struct usb_device_id *i
mutex_init(&wacom->lock);
INIT_WORK(&wacom->wireless_work, wacom_wireless_work);
INIT_WORK(&wacom->battery_work, wacom_battery_work);
+ INIT_WORK(&wacom->remote_work, wacom_remote_work);
+ spin_lock_init(&wacom->remote_lock);
+
+ if (kfifo_alloc(&wacom->remote_fifo,
+ 5 * sizeof(struct wacom_remote_data),
+ GFP_KERNEL)) {
+ dev_err(&wacom->intf->dev,
+ "%s:failed allocating remote_fifo\n", __func__);
+ error = -ENOMEM;
+ goto fail2;
+ }
+
usb_make_path(dev, wacom->phys, sizeof(wacom->phys));
strlcat(wacom->phys, "/input0", sizeof(wacom->phys));
@@ -1738,6 +1810,7 @@ static int wacom_probe(struct usb_interface *intf, const
struct usb_device_id *i
fail4: wacom_remove_shared_data(wacom_wac);
fail3: usb_free_urb(wacom->irq);
wacom_destroy_battery(wacom);
+ kfifo_free(&wacom->remote_fifo);
fail2: usb_free_coherent(dev, WACOM_PKGLEN_MAX, wacom_wac->data,
wacom->data_dma);
fail1:
return error;
@@ -1753,6 +1826,8 @@ static void wacom_disconnect(struct usb_interface *intf)
usb_kill_urb(wacom->irq);
cancel_work_sync(&wacom->wireless_work);
cancel_work_sync(&wacom->battery_work);
+ cancel_work_sync(&wacom->remote_work);
+ kfifo_free(&wacom->remote_fifo);
for (i = 0; i < WACOM_MAX_REMOTES; i++) {
if (wacom->remote_group[i].name) {
wacom_remote_destroy_attr_group(wacom,
diff --git a/3.7/wacom_wac.c b/3.7/wacom_wac.c
index 5887561..214e0e2 100644
--- a/3.7/wacom_wac.c
+++ b/3.7/wacom_wac.c
@@ -772,52 +772,41 @@ static int wacom_remote_irq(struct wacom_wac *wacom_wac,
size_t len)
return 1;
}
-static int wacom_remote_status_irq(struct wacom_wac *wacom_wac, size_t len)
+static void wacom_remote_status_irq(struct wacom_wac *wacom_wac, size_t len)
{
struct wacom *wacom = container_of(wacom_wac, struct wacom, wacom_wac);
+ struct device *dev = &wacom->intf->dev;
unsigned char *data = wacom_wac->data;
- int i;
+ struct wacom_remote_data remote_data;
+ unsigned long flags;
+ int i, ret;
if (data[0] != WACOM_REPORT_DEVICE_LIST)
- return 0;
+ return;
+
+ memset(&remote_data, 0, sizeof(struct wacom_remote_data));
for (i = 0; i < WACOM_MAX_REMOTES; i++) {
int j = i * 6;
int serial = (data[j+6] << 16) + (data[j+5] << 8) + data[j+4];
bool connected = data[j+2];
- if (connected) {
- int k;
-
- if (wacom_wac->serial[i] == serial)
- continue;
-
- if (wacom_wac->serial[i]) {
- wacom_remote_destroy_attr_group(wacom,
- wacom_wac->serial[i]);
- }
-
- /* A remote can pair more than once with an EKR,
- * check to make sure this serial isn't already paired.
- */
- for (k = 0; k < WACOM_MAX_REMOTES; k++) {
- if (wacom_wac->serial[k] == serial)
- break;
- }
+ remote_data.remote[i].serial = serial;
+ remote_data.remote[i].connected = connected;
+ }
- if (k < WACOM_MAX_REMOTES) {
- wacom_wac->serial[i] = serial;
- continue;
- }
- wacom_remote_create_attr_group(wacom, serial, i);
+ spin_lock_irqsave(&wacom->remote_lock, flags);
- } else if (wacom_wac->serial[i]) {
- wacom_remote_destroy_attr_group(wacom,
- wacom_wac->serial[i]);
- }
+ ret = kfifo_in(&wacom->remote_fifo, &remote_data, sizeof(remote_data));
+ if (ret != sizeof(remote_data)) {
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+ dev_err(dev, "Can't queue Remote status event.\n");
+ return;
}
- return 0;
+ spin_unlock_irqrestore(&wacom->remote_lock, flags);
+
+ wacom_schedule_work(wacom_wac, WACOM_WORKER_REMOTE);
}
static int wacom_intuos_general(struct wacom_wac *wacom)
@@ -1702,8 +1691,9 @@ void wacom_wac_irq(struct wacom_wac *wacom_wac, size_t
len)
break;
case REMOTE:
+ sync = false;
if (wacom_wac->data[0] == WACOM_REPORT_DEVICE_LIST)
- sync = wacom_remote_status_irq(wacom_wac, len);
+ wacom_remote_status_irq(wacom_wac, len);
else
sync = wacom_remote_irq(wacom_wac, len);
break;
diff --git a/3.7/wacom_wac.h b/3.7/wacom_wac.h
index 4c47d10..0ade39c 100644
--- a/3.7/wacom_wac.h
+++ b/3.7/wacom_wac.h
@@ -165,6 +165,13 @@ struct wacom_shared {
struct input_dev *touch_input;
};
+struct wacom_remote_data {
+ struct {
+ u32 serial;
+ bool connected;
+ } remote[WACOM_MAX_REMOTES];
+};
+
struct wacom_wac {
char name[WACOM_NAME_MAX];
char bat_name[WACOM_NAME_MAX];
--
2.7.4
------------------------------------------------------------------------------
Check out the vibrant tech community on one of the world's most
engaging tech sites, SlashDot.org! http://sdm.link/slashdot
_______________________________________________
Linuxwacom-devel mailing list
Linuxwacom-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linuxwacom-devel
