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

Commit e6ae32ba authored by Atif Niyaz's avatar Atif Niyaz Committed by Hridya Valsaraju
Browse files

UPSTREAM: Input: allow drivers specify timestamp for input events 



Currently, evdev stamps events with timestamps acquired in evdev_events()
However, this timestamping may not be accurate in terms of measuring
when the actual event happened.

Let's allow individual drivers specify timestamp in order to provide a more
accurate sense of time for the event. It is expected that drivers will set the
timestamp in their hard interrupt routine.

Bug: 150896413
Signed-off-by: default avatarAtif Niyaz <atifniyaz@google.com>
Signed-off-by: default avatarDmitry Torokhov <dmitry.torokhov@gmail.com>
Change-Id: I718209b41958a771c48f6069a597cec469c4074d
(cherry picked from commit 3b51c44bd6936e86a7180abd9aebc4387a479253)
Signed-off-by: default avatarHridya Valsaraju <hridya@google.com>
parent e203009d

drivers/input/evdev.c

+8 −27
Original line number Diff line number Diff line
@@ -28,13 +28,6 @@ 
#include <linux/cdev.h>

#include "input-compat.h"



enum evdev_clock_type {

	EV_CLK_REAL = 0,

	EV_CLK_MONO,

	EV_CLK_BOOT,

	EV_CLK_MAX

};



struct evdev {

	int open;

	struct input_handle handle;
@@ -56,7 +49,7 @@ struct evdev_client { 
	struct fasync_struct *fasync;

	struct evdev *evdev;

	struct list_head node;

	unsigned int clk_type;

	enum input_clock_type clk_type;

	bool revoked;

	unsigned long *evmasks[EV_CNT];

	unsigned int bufsize;
@@ -152,17 +145,10 @@ static void __evdev_flush_queue(struct evdev_client *client, unsigned int type) 


static void __evdev_queue_syn_dropped(struct evdev_client *client)

{

	ktime_t *ev_time = input_get_timestamp(client->evdev->handle.dev);

	struct timespec64 ts = ktime_to_timespec64(ev_time[client->clk_type]);

	struct input_event ev;

	ktime_t time;

	struct timespec64 ts;



	time = client->clk_type == EV_CLK_REAL ?

			ktime_get_real() :

			client->clk_type == EV_CLK_MONO ?

				ktime_get() :

				ktime_get_boottime();



	ts = ktime_to_timespec64(time);

	ev.input_event_sec = ts.tv_sec;

	ev.input_event_usec = ts.tv_nsec / NSEC_PER_USEC;

	ev.type = EV_SYN;
@@ -191,18 +177,18 @@ static void evdev_queue_syn_dropped(struct evdev_client *client) 
static int evdev_set_clk_type(struct evdev_client *client, unsigned int clkid)

{

	unsigned long flags;

	unsigned int clk_type;

	enum input_clock_type clk_type;



	switch (clkid) {



	case CLOCK_REALTIME:

		clk_type = EV_CLK_REAL;

		clk_type = INPUT_CLK_REAL;

		break;

	case CLOCK_MONOTONIC:

		clk_type = EV_CLK_MONO;

		clk_type = INPUT_CLK_MONO;

		break;

	case CLOCK_BOOTTIME:

		clk_type = EV_CLK_BOOT;

		clk_type = INPUT_CLK_BOOT;

		break;

	default:

		return -EINVAL;
@@ -310,12 +296,7 @@ static void evdev_events(struct input_handle *handle, 
{

	struct evdev *evdev = handle->private;

	struct evdev_client *client;

	ktime_t ev_time[EV_CLK_MAX];



	ev_time[EV_CLK_MONO] = ktime_get();

	ev_time[EV_CLK_REAL] = ktime_mono_to_real(ev_time[EV_CLK_MONO]);

	ev_time[EV_CLK_BOOT] = ktime_mono_to_any(ev_time[EV_CLK_MONO],

						 TK_OFFS_BOOT);

	ktime_t *ev_time = input_get_timestamp(handle->dev);



	rcu_read_lock();

drivers/input/input.c

+40 −0
Original line number Diff line number Diff line
@@ -1904,6 +1904,46 @@ void input_free_device(struct input_dev *dev) 
}

EXPORT_SYMBOL(input_free_device);



/**

 * input_set_timestamp - set timestamp for input events

 * @dev: input device to set timestamp for

 * @timestamp: the time at which the event has occurred

 *   in CLOCK_MONOTONIC

 *

 * This function is intended to provide to the input system a more

 * accurate time of when an event actually occurred. The driver should

 * call this function as soon as a timestamp is acquired ensuring

 * clock conversions in input_set_timestamp are done correctly.

 *

 * The system entering suspend state between timestamp acquisition and

 * calling input_set_timestamp can result in inaccurate conversions.

 */

void input_set_timestamp(struct input_dev *dev, ktime_t timestamp)

{

	dev->timestamp[INPUT_CLK_MONO] = timestamp;

	dev->timestamp[INPUT_CLK_REAL] = ktime_mono_to_real(timestamp);

	dev->timestamp[INPUT_CLK_BOOT] = ktime_mono_to_any(timestamp,

							   TK_OFFS_BOOT);

}

EXPORT_SYMBOL(input_set_timestamp);



/**

 * input_get_timestamp - get timestamp for input events

 * @dev: input device to get timestamp from

 *

 * A valid timestamp is a timestamp of non-zero value.

 */

ktime_t *input_get_timestamp(struct input_dev *dev)

{

	const ktime_t invalid_timestamp = ktime_set(0, 0);



	if (!ktime_compare(dev->timestamp[INPUT_CLK_MONO], invalid_timestamp))

		input_set_timestamp(dev, ktime_get());



	return dev->timestamp;

}

EXPORT_SYMBOL(input_get_timestamp);



/**

 * input_set_capability - mark device as capable of a certain event

 * @dev: device that is capable of emitting or accepting event

include/linux/input.h

+14 −0
Original line number Diff line number Diff line
@@ -36,6 +36,13 @@ struct input_value { 
	__s32 value;

};



enum input_clock_type {

	INPUT_CLK_REAL = 0,

	INPUT_CLK_MONO,

	INPUT_CLK_BOOT,

	INPUT_CLK_MAX

};



/**

 * struct input_dev - represents an input device

 * @name: name of the device
@@ -117,6 +124,8 @@ struct input_value { 
 * @vals: array of values queued in the current frame

 * @devres_managed: indicates that devices is managed with devres framework

 *	and needs not be explicitly unregistered or freed.

 * @timestamp: storage for a timestamp set by input_set_timestamp called

 *  by a driver

 */

struct input_dev {

	const char *name;
@@ -187,6 +196,8 @@ struct input_dev { 
	struct input_value *vals;



	bool devres_managed;



	ktime_t timestamp[INPUT_CLK_MAX];

};

#define to_input_dev(d) container_of(d, struct input_dev, dev)
@@ -385,6 +396,9 @@ void input_close_device(struct input_handle *); 


int input_flush_device(struct input_handle *handle, struct file *file);



void input_set_timestamp(struct input_dev *dev, ktime_t timestamp);

ktime_t *input_get_timestamp(struct input_dev *dev);



void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value);

void input_inject_event(struct input_handle *handle, unsigned int type, unsigned int code, int value);