redonkable
/
remarkable-linux
1
0
Fork 0
Code Releases Activity

evdev: Applied patch https://patchwork.kernel.org/patch/11049457/ to be able to set custom timestamps for input events.

pull/10/head
Thomas Ingebretsen 2019-12-04 20:58:43 +01:00 committed by Steinar Bakkemo
parent 871b0416e2
commit 3b3aa48d1a
3 changed files with 61 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
drivers/input/evdev.c
View File

@ -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;
@ -156,14 +149,8 @@ static void __evdev_flush_queue(struct evdev_client *client, unsigned int type)
static void __evdev_queue_syn_dropped(struct evdev_client *client)
{
struct input_event ev;
ktime_t time;
time = client->clk_type == EV_CLK_REAL ?
ktime_get_real() :
client->clk_type == EV_CLK_MONO ?
ktime_get() :
ktime_get_boottime();
ktime_t time = input_get_timestamp(client->evdev->handle.dev);
ev.time = ktime_to_timeval(time);
ev.type = EV_SYN;
ev.code = SYN_DROPPED;
@ -188,21 +175,21 @@ static void evdev_queue_syn_dropped(struct evdev_client *client)
spin_unlock_irqrestore(&client->buffer_lock, flags);
}
static int evdev_set_clk_type(struct evdev_client *client, unsigned int clkid)
static int evdev_set_clk_type(struct evdev_client *client, clockid_t 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;
@ -304,12 +291,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();

16
drivers/input/input.c
View File

@ -1898,6 +1898,22 @@ void input_free_device(struct input_dev *dev)
}
EXPORT_SYMBOL(input_free_device);
/**
* 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

37
include/linux/input.h
View File

@ -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,32 @@ void input_close_device(struct input_handle *);
int input_flush_device(struct input_handle *handle, struct file *file);
/**
* 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 a suspend between timestamp acquisition and
* calling input_set_timestamp can result in inaccurate conversions.
*
*/
static inline 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);
}
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);