On Thu, Dec 18, 2014 at 05:12:29AM +0530, Aniroop Mathur wrote:

Hello Mr. Torokhov,

On Thu, Dec 18, 2014 at 4:47 AM, Dmitry Torokhov
[off-list ref] wrote:

quoted

On Thu, Dec 18, 2014 at 04:37:54AM +0530, Aniroop Mathur wrote:

quoted

This patch adds support for CLOCK_BOOTTIME for input event timestamp.
CLOCK_BOOTTIME includes suspend time, so it would allow aplications
to get correct time difference between two events even when system
resumes from suspend state.

Signed-off-by: Aniroop Mathur <redacted>
---
 drivers/input/evdev.c | 52 +++++++++++++++++++++++++++++++++++++--------------
 1 file changed, 38 insertions(+), 14 deletions(-)

diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index de05545..bfca214 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c

@@ -28,6 +28,13 @@
 #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;

@@ -49,12 +56,29 @@ struct evdev_client {
      struct fasync_struct *fasync;
      struct evdev *evdev;
      struct list_head node;
-     int clkid;
+     int clk_type;
      bool revoked;
      unsigned int bufsize;
      struct input_event buffer[];
 };

+static int evdev_set_clk_type(int id, struct evdev_client *client)
+{
+     switch (id) {
+
+     case CLOCK_REALTIME:
+             client->clk_type = EV_CLK_REAL; break;
+     case CLOCK_MONOTONIC:
+             client->clk_type = EV_CLK_MONO; break;
+     case CLOCK_BOOTTIME:
+             client->clk_type = EV_CLK_BOOT; break;

Please put "break" on separate lines.

quoted

+     default:
+             return -EINVAL;
+     }
+
+     return 0;
+}
+
 /* flush queued events of type @type, caller must hold client->buffer_lock */
 static void __evdev_flush_queue(struct evdev_client *client, unsigned int type)
 {

@@ -108,8 +132,9 @@ static void evdev_queue_syn_dropped(struct evdev_client *client)
      struct input_event ev;
      ktime_t time;

-     time = (client->clkid == CLOCK_MONOTONIC) ?
-             ktime_get() : ktime_get_real();
+     time = (client->clk_type == EV_CLK_REAL) ?
+             ktime_get_real() : (client->clk_type == EV_CLK_MONO) ?
+             ktime_get() : ktime_get_boottime();

      ev.time = ktime_to_timeval(time);
      ev.type = EV_SYN;

@@ -159,7 +184,7 @@ static void __pass_event(struct evdev_client *client,

 static void evdev_pass_values(struct evdev_client *client,
                      const struct input_value *vals, unsigned int count,
-                     ktime_t mono, ktime_t real)
+                     ktime_t *ev_time)
 {
      struct evdev *evdev = client->evdev;
      const struct input_value *v;

@@ -169,8 +194,7 @@ static void evdev_pass_values(struct evdev_client *client,
      if (client->revoked)
              return;

-     event.time = ktime_to_timeval(client->clkid == CLOCK_MONOTONIC ?
-                                   mono : real);
+     event.time = ktime_to_timeval(ev_time[client->clk_type]);

      /* Interrupts are disabled, just acquire the lock. */
      spin_lock(&client->buffer_lock);

@@ -198,21 +222,22 @@ static void evdev_events(struct input_handle *handle,
 {
      struct evdev *evdev = handle->private;
      struct evdev_client *client;
-     ktime_t time_mono, time_real;
+     ktime_t ev_time[EV_CLK_MAX];

-     time_mono = ktime_get();
-     time_real = ktime_mono_to_real(time_mono);
+     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_BOOT],
+                                              TK_OFFS_BOOT);

Nope, that should have read

        ev_time[EV_CLK_BOOT] = ktime_mono_to_any(ev_time[EV_CLK_BOOT],
                                                 TK_OFFS_BOOT);

Ahhh... okay need to change BOOT to MONO

Ugh, apparently I failed to actually type properly what I meant. Glad
you still understood me ;)

Thanks.

-- 
Dmitry