Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e6f2813a authored by Benjamin Tissoires's avatar Benjamin Tissoires Committed by Jiri Kosina
Browse files

HID: wacom: EKR: add a worker to add/remove resources on addition/removal 



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: default avatarBenjamin Tissoires <benjamin.tissoires@redhat.com>
Acked-by: default avatarPing Cheng <pingc@wacom.com>
Signed-off-by: default avatarJiri Kosina <jkosina@suse.cz>
parent a50aac71

drivers/hid/wacom.h

+8 −3
Original line number Diff line number Diff line
@@ -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>
@@ -108,6 +109,7 @@ 
enum wacom_worker {

	WACOM_WORKER_WIRELESS,

	WACOM_WORKER_BATTERY,

	WACOM_WORKER_REMOTE,

};



struct wacom_group_leds {
@@ -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;

	struct wacom_leds {

		struct wacom_group_leds *groups;

		u8 llv;       /* status led brightness no button (1..127) */
@@ -149,6 +154,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;

	}

}
@@ -168,7 +176,4 @@ 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);

#endif

drivers/hid/wacom_sys.c

+77 −3
Original line number Diff line number Diff line
@@ -1294,7 +1294,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;
@@ -1318,7 +1319,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;
@@ -1889,6 +1890,65 @@ static void wacom_wireless_work(struct work_struct *work) 
	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)

{
@@ -1931,6 +1991,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);
@@ -1953,8 +2024,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;

}
@@ -1972,6 +2044,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);

drivers/hid/wacom_wac.c

+21 −32
Original line number Diff line number Diff line
@@ -823,52 +823,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]);

		remote_data.remote[i].serial = serial;

		remote_data.remote[i].connected = connected;

	}



			/* 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;

			}

	spin_lock_irqsave(&wacom->remote_lock, flags);



			if (k < WACOM_MAX_REMOTES) {

				wacom_wac->serial[i] = serial;

				continue;

	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;

	}

			wacom_remote_create_attr_group(wacom, serial, i);



		} else if (wacom_wac->serial[i]) {

			wacom_remote_destroy_attr_group(wacom,

							wacom_wac->serial[i]);

		}

	}

	spin_unlock_irqrestore(&wacom->remote_lock, flags);



	return 0;

	wacom_schedule_work(wacom_wac, WACOM_WORKER_REMOTE);

}



static int wacom_intuos_general(struct wacom_wac *wacom)
@@ -2310,8 +2298,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;

drivers/hid/wacom_wac.h

+7 −0
Original line number Diff line number Diff line
@@ -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];