diff --git a/src/evdev-middle-button.c b/src/evdev-middle-button.c
index 48330d39..397b699c 100644
--- a/src/evdev-middle-button.c
+++ b/src/evdev-middle-button.c
@@ -27,7 +27,7 @@
 
 #include "evdev.h"
 
-#define MIDDLEBUTTON_TIMEOUT 50
+#define MIDDLEBUTTON_TIMEOUT ms2us(50)
 
 /*****************************************
  * BEFORE YOU EDIT THIS FILE, look at the state diagram in
diff --git a/src/evdev-mt-touchpad-buttons.c b/src/evdev-mt-touchpad-buttons.c
index f16d1b87..8822e08c 100644
--- a/src/evdev-mt-touchpad-buttons.c
+++ b/src/evdev-mt-touchpad-buttons.c
@@ -32,8 +32,8 @@
 
 #include "evdev-mt-touchpad.h"
 
-#define DEFAULT_BUTTON_ENTER_TIMEOUT 100 /* ms */
-#define DEFAULT_BUTTON_LEAVE_TIMEOUT 300 /* ms */
+#define DEFAULT_BUTTON_ENTER_TIMEOUT ms2us(100)
+#define DEFAULT_BUTTON_LEAVE_TIMEOUT ms2us(300)
 
 /*****************************************
  * BEFORE YOU EDIT THIS FILE, look at the state diagram in
@@ -913,8 +913,8 @@ tp_notify_clickpadbutton(struct tp_dispatch *tp,
 		struct evdev_dispatch *dispatch = tp->buttons.trackpoint->dispatch;
 		struct input_event event;
 
-		event.time.tv_sec = time/1000;
-		event.time.tv_usec = (time % 1000) * 1000;
+		event.time.tv_sec = time / ms2us(1000);
+		event.time.tv_usec = time % ms2us(1000);
 		event.type = EV_KEY;
 		event.code = button;
 		event.value = (state == LIBINPUT_BUTTON_STATE_PRESSED) ? 1 : 0;
diff --git a/src/evdev-mt-touchpad-edge-scroll.c b/src/evdev-mt-touchpad-edge-scroll.c
index 928f6029..49028087 100644
--- a/src/evdev-mt-touchpad-edge-scroll.c
+++ b/src/evdev-mt-touchpad-edge-scroll.c
@@ -93,7 +93,7 @@ static inline void
 tp_edge_scroll_set_timer(struct tp_dispatch *tp,
 			 struct tp_touch *t)
 {
-	const int DEFAULT_SCROLL_LOCK_TIMEOUT = 300; /* ms */
+	const int DEFAULT_SCROLL_LOCK_TIMEOUT = ms2us(300);
 	/* if we use software buttons, we disable timeout-based
 	 * edge scrolling. A finger resting on the button areas is
 	 * likely there to trigger a button event.
diff --git a/src/evdev-mt-touchpad-gestures.c b/src/evdev-mt-touchpad-gestures.c
index 1acf1111..8bcdeb40 100644
--- a/src/evdev-mt-touchpad-gestures.c
+++ b/src/evdev-mt-touchpad-gestures.c
@@ -29,8 +29,8 @@
 
 #include "evdev-mt-touchpad.h"
 
-#define DEFAULT_GESTURE_SWITCH_TIMEOUT 100 /* ms */
-#define DEFAULT_GESTURE_2FG_SCROLL_TIMEOUT 1000 /* ms */
+#define DEFAULT_GESTURE_SWITCH_TIMEOUT ms2us(100)
+#define DEFAULT_GESTURE_2FG_SCROLL_TIMEOUT ms2us(1000)
 
 static inline const char*
 gesture_state_to_str(enum tp_gesture_2fg_state state)
diff --git a/src/evdev-mt-touchpad-tap.c b/src/evdev-mt-touchpad-tap.c
index b2977545..de4945e6 100644
--- a/src/evdev-mt-touchpad-tap.c
+++ b/src/evdev-mt-touchpad-tap.c
@@ -35,8 +35,8 @@
 
 #include "evdev-mt-touchpad.h"
 
-#define DEFAULT_TAP_TIMEOUT_PERIOD 180
-#define DEFAULT_DRAG_TIMEOUT_PERIOD 300
+#define DEFAULT_TAP_TIMEOUT_PERIOD ms2us(180)
+#define DEFAULT_DRAG_TIMEOUT_PERIOD ms2us(300)
 #define DEFAULT_TAP_MOVE_THRESHOLD TP_MM_TO_DPI_NORMALIZED(3)
 
 enum tap_event {
diff --git a/src/evdev-mt-touchpad.c b/src/evdev-mt-touchpad.c
index 257af999..ebb8cee0 100644
--- a/src/evdev-mt-touchpad.c
+++ b/src/evdev-mt-touchpad.c
@@ -30,9 +30,9 @@
 
 #include "evdev-mt-touchpad.h"
 
-#define DEFAULT_TRACKPOINT_ACTIVITY_TIMEOUT 300 /* ms */
-#define DEFAULT_KEYBOARD_ACTIVITY_TIMEOUT_1 200 /* ms */
-#define DEFAULT_KEYBOARD_ACTIVITY_TIMEOUT_2 500 /* ms */
+#define DEFAULT_TRACKPOINT_ACTIVITY_TIMEOUT ms2us(300)
+#define DEFAULT_KEYBOARD_ACTIVITY_TIMEOUT_1 ms2us(200)
+#define DEFAULT_KEYBOARD_ACTIVITY_TIMEOUT_2 ms2us(500)
 #define FAKE_FINGER_OVERFLOW (1 << 7)
 
 static inline int
@@ -588,7 +588,7 @@ tp_palm_detect_trackpoint(struct tp_dispatch *tp,
 static void
 tp_palm_detect(struct tp_dispatch *tp, struct tp_touch *t, uint64_t time)
 {
-	const int PALM_TIMEOUT = 200; /* ms */
+	const int PALM_TIMEOUT = ms2us(200);
 	const int DIRECTIONS = NE|E|SE|SW|W|NW;
 	struct device_float_coords delta;
 	int dirs;
diff --git a/src/evdev.c b/src/evdev.c
index 9af1841e..ee904d31 100644
--- a/src/evdev.c
+++ b/src/evdev.c
@@ -44,7 +44,7 @@
 #include "libinput-private.h"
 
 #define DEFAULT_WHEEL_CLICK_ANGLE 15
-#define DEFAULT_MIDDLE_BUTTON_SCROLL_TIMEOUT 200
+#define DEFAULT_MIDDLE_BUTTON_SCROLL_TIMEOUT ms2us(200)
 
 enum evdev_key_type {
 	EVDEV_KEY_TYPE_NONE,
@@ -457,7 +457,7 @@ evdev_button_scroll_button(struct evdev_device *device,
 {
 	if (is_press) {
 		libinput_timer_set(&device->scroll.timer,
-				time + DEFAULT_MIDDLE_BUTTON_SCROLL_TIMEOUT);
+				   time + DEFAULT_MIDDLE_BUTTON_SCROLL_TIMEOUT);
 		device->scroll.button_down_time = time;
 	} else {
 		libinput_timer_cancel(&device->scroll.timer);
@@ -1270,7 +1270,7 @@ static inline void
 evdev_process_event(struct evdev_device *device, struct input_event *e)
 {
 	struct evdev_dispatch *dispatch = device->dispatch;
-	uint64_t time = e->time.tv_sec * 1000ULL + e->time.tv_usec / 1000;
+	uint64_t time = s2us(e->time.tv_sec) + e->time.tv_usec;
 
 #if 0
 	if (libevdev_event_is_code(e, EV_SYN, SYN_REPORT))
@@ -2153,7 +2153,7 @@ evdev_device_create(struct libinput_seat *seat,
 	device->dpi = DEFAULT_MOUSE_DPI;
 
 	/* at most 5 SYN_DROPPED log-messages per 30s */
-	ratelimit_init(&device->syn_drop_limit, 30ULL * 1000, 5);
+	ratelimit_init(&device->syn_drop_limit, s2us(30), 5);
 
 	matrix_init_identity(&device->abs.calibration);
 	matrix_init_identity(&device->abs.usermatrix);
diff --git a/src/filter.c b/src/filter.c
index 35449f56..f8f94096 100644
--- a/src/filter.c
+++ b/src/filter.c
@@ -77,7 +77,7 @@ filter_get_speed(struct motion_filter *filter)
  * Default parameters for pointer acceleration profiles.
  */
 
-#define DEFAULT_THRESHOLD 0.4			/* in units/ms */
+#define DEFAULT_THRESHOLD 0.0004		/* in units/us */
 #define DEFAULT_ACCELERATION 2.0		/* unitless factor */
 #define DEFAULT_INCLINE 1.1			/* unitless factor */
 
@@ -85,13 +85,13 @@ filter_get_speed(struct motion_filter *filter)
  * Pointer acceleration filter constants
  */
 
-#define MAX_VELOCITY_DIFF	1.0 /* units/ms */
-#define MOTION_TIMEOUT		1000 /* (ms) */
+#define MAX_VELOCITY_DIFF	0.001 /* units/us */
+#define MOTION_TIMEOUT		ms2us(1000)
 #define NUM_POINTER_TRACKERS	16
 
 struct pointer_tracker {
 	struct normalized_coords delta; /* delta to most recent event */
-	uint64_t time;  /* ms */
+	uint64_t time;  /* us */
 	int dir;
 };
 
@@ -101,14 +101,14 @@ struct pointer_accelerator {
 
 	accel_profile_func_t profile;
 
-	double velocity;	/* units/ms */
-	double last_velocity;	/* units/ms */
+	double velocity;	/* units/us */
+	double last_velocity;	/* units/us */
 	struct normalized_coords last;
 
 	struct pointer_tracker *trackers;
 	int cur_tracker;
 
-	double threshold;	/* units/ms */
+	double threshold;	/* units/us */
 	double accel;		/* unitless factor */
 	double incline;		/* incline of the function */
 
@@ -150,8 +150,7 @@ static double
 calculate_tracker_velocity(struct pointer_tracker *tracker, uint64_t time)
 {
 	double tdelta = time - tracker->time + 1;
-
-	return normalized_length(tracker->delta) / tdelta; /* units/ms */
+	return normalized_length(tracker->delta) / tdelta; /* units/us */
 }
 
 static inline double
@@ -221,7 +220,7 @@ calculate_velocity(struct pointer_accelerator *accel, uint64_t time)
 		}
 	}
 
-	return result; /* units/ms */
+	return result; /* units/us */
 }
 
 static double
@@ -261,7 +260,7 @@ accelerator_filter(struct motion_filter *filter,
 {
 	struct pointer_accelerator *accel =
 		(struct pointer_accelerator *) filter;
-	double velocity; /* units/ms */
+	double velocity; /* units/us */
 	double accel_value; /* unitless factor */
 	struct normalized_coords accelerated;
 	struct normalized_coords unnormalized;
@@ -334,9 +333,9 @@ accelerator_set_speed(struct motion_filter *filter,
 	assert(speed >= -1.0 && speed <= 1.0);
 
 	/* delay when accel kicks in */
-	accel_filter->threshold = DEFAULT_THRESHOLD - speed / 4.0;
-	if (accel_filter->threshold < 0.2)
-		accel_filter->threshold = 0.2;
+	accel_filter->threshold = DEFAULT_THRESHOLD - speed / 4000.0;
+	if (accel_filter->threshold < 0.0002)
+		accel_filter->threshold = 0.0002;
 
 	/* adjust max accel factor */
 	accel_filter->accel = DEFAULT_ACCELERATION + speed * 1.5;
@@ -398,7 +397,7 @@ create_pointer_accelerator_filter(accel_profile_func_t profile,
 double
 pointer_accel_profile_linear_low_dpi(struct motion_filter *filter,
 				     void *data,
-				     double speed_in, /* in device units */
+				     double speed_in, /* in device units (units/us) */
 				     uint64_t time)
 {
 	struct pointer_accelerator *accel_filter =
@@ -406,15 +405,15 @@ pointer_accel_profile_linear_low_dpi(struct motion_filter *filter,
 
 	double s1, s2;
 	double max_accel = accel_filter->accel; /* unitless factor */
-	const double threshold = accel_filter->threshold; /* units/ms */
+	const double threshold = accel_filter->threshold; /* units/us */
 	const double incline = accel_filter->incline;
 	double factor;
 	double dpi_factor = accel_filter->dpi_factor;
 
 	max_accel /= dpi_factor;
 
-	s1 = min(1, 0.3 + speed_in * 10);
-	s2 = 1 + (speed_in - threshold * dpi_factor) * incline;
+	s1 = min(1, 0.3 + speed_in * 10000.0);
+	s2 = 1 + (speed_in * 1000.0 - threshold * dpi_factor * 1000.0) * incline;
 
 	factor = min(max_accel, s2 > 1 ? s2 : s1);
 
@@ -432,12 +431,12 @@ pointer_accel_profile_linear(struct motion_filter *filter,
 
 	double s1, s2;
 	const double max_accel = accel_filter->accel; /* unitless factor */
-	const double threshold = accel_filter->threshold; /* units/ms */
+	const double threshold = accel_filter->threshold; /* units/us */
 	const double incline = accel_filter->incline;
 	double factor;
 
-	s1 = min(1, 0.3 + speed_in * 10);
-	s2 = 1 + (speed_in - threshold) * incline;
+	s1 = min(1, 0.3 + speed_in * 10 * 1000.0);
+	s2 = 1 + (speed_in * 1000.0 - threshold * 1000.0) * incline;
 
 	factor =  min(max_accel, s2 > 1 ? s2 : s1);
 
@@ -489,7 +488,7 @@ touchpad_lenovo_x230_accel_profile(struct motion_filter *filter,
 	const double max_accel = accel_filter->accel *
 				  TP_MAGIC_LOW_RES_FACTOR; /* unitless factor */
 	const double threshold = accel_filter->threshold /
-				  TP_MAGIC_LOW_RES_FACTOR; /* units/ms */
+				  TP_MAGIC_LOW_RES_FACTOR; /* units/us */
 	const double incline = accel_filter->incline * TP_MAGIC_LOW_RES_FACTOR;
 
 	speed_in *= TP_MAGIC_SLOWDOWN / TP_MAGIC_LOW_RES_FACTOR;
diff --git a/src/libinput-private.h b/src/libinput-private.h
index 110955db..e0ba51b5 100644
--- a/src/libinput-private.h
+++ b/src/libinput-private.h
@@ -422,7 +422,7 @@ libinput_now(struct libinput *libinput)
 		return 0;
 	}
 
-	return ts.tv_sec * 1000ULL + ts.tv_nsec / 1000000;
+	return s2us(ts.tv_sec) + ns2us(ts.tv_nsec);
 }
 
 static inline struct device_float_coords
diff --git a/src/libinput-util.c b/src/libinput-util.c
index a383fa17..d35d7022 100644
--- a/src/libinput-util.c
+++ b/src/libinput-util.c
@@ -72,9 +72,9 @@ list_empty(const struct list *list)
 }
 
 void
-ratelimit_init(struct ratelimit *r, uint64_t ival_ms, unsigned int burst)
+ratelimit_init(struct ratelimit *r, uint64_t ival_us, unsigned int burst)
 {
-	r->interval = ival_ms;
+	r->interval = ival_us;
 	r->begin = 0;
 	r->burst = burst;
 	r->num = 0;
@@ -97,17 +97,17 @@ enum ratelimit_state
 ratelimit_test(struct ratelimit *r)
 {
 	struct timespec ts;
-	uint64_t mtime;
+	uint64_t utime;
 
 	if (r->interval <= 0 || r->burst <= 0)
 		return RATELIMIT_PASS;
 
 	clock_gettime(CLOCK_MONOTONIC, &ts);
-	mtime = ts.tv_sec * 1000 + ts.tv_nsec / 1000 / 1000;
+	utime = s2us(ts.tv_sec) + ns2us(ts.tv_nsec);
 
-	if (r->begin <= 0 || r->begin + r->interval < mtime) {
+	if (r->begin <= 0 || r->begin + r->interval < utime) {
 		/* reset counter */
-		r->begin = mtime;
+		r->begin = utime;
 		r->num = 1;
 		return RATELIMIT_PASS;
 	} else if (r->num < r->burst) {
diff --git a/src/libinput-util.h b/src/libinput-util.h
index 3832b728..de9b98e1 100644
--- a/src/libinput-util.h
+++ b/src/libinput-util.h
@@ -303,4 +303,34 @@ int parse_mouse_wheel_click_angle_property(const char *prop);
 double parse_trackpoint_accel_property(const char *prop);
 bool parse_dimension_property(const char *prop, size_t *width, size_t *height);
 
+static inline uint64_t
+us(uint64_t us)
+{
+	return us;
+}
+
+static inline uint64_t
+ns2us(uint64_t ns)
+{
+	return us(ns / 1000);
+}
+
+static inline uint64_t
+ms2us(uint64_t ms)
+{
+	return us(ms * 1000);
+}
+
+static inline uint64_t
+s2us(uint64_t s)
+{
+	return ms2us(s * 1000);
+}
+
+static inline uint32_t
+us2ms(uint64_t us)
+{
+	return (uint32_t)(us / 1000);
+}
+
 #endif /* LIBINPUT_UTIL_H */
diff --git a/src/libinput.c b/src/libinput.c
index cab6224a..69a6aef2 100644
--- a/src/libinput.c
+++ b/src/libinput.c
@@ -86,7 +86,7 @@ struct libinput_event_device_notify {
 
 struct libinput_event_keyboard {
 	struct libinput_event base;
-	uint32_t time;
+	uint64_t time;
 	uint32_t key;
 	uint32_t seat_key_count;
 	enum libinput_key_state state;
@@ -94,7 +94,7 @@ struct libinput_event_keyboard {
 
 struct libinput_event_pointer {
 	struct libinput_event base;
-	uint32_t time;
+	uint64_t time;
 	struct normalized_coords delta;
 	struct device_float_coords delta_raw;
 	struct device_coords absolute;
@@ -108,7 +108,7 @@ struct libinput_event_pointer {
 
 struct libinput_event_touch {
 	struct libinput_event base;
-	uint32_t time;
+	uint64_t time;
 	int32_t slot;
 	int32_t seat_slot;
 	struct device_coords point;
@@ -116,7 +116,7 @@ struct libinput_event_touch {
 
 struct libinput_event_gesture {
 	struct libinput_event base;
-	uint32_t time;
+	uint64_t time;
 	int finger_count;
 	int cancelled;
 	struct normalized_coords delta;
@@ -278,6 +278,17 @@ libinput_event_get_device_notify_event(struct libinput_event *event)
 
 LIBINPUT_EXPORT uint32_t
 libinput_event_keyboard_get_time(struct libinput_event_keyboard *event)
+{
+	require_event_type(libinput_event_get_context(&event->base),
+			   event->base.type,
+			   0,
+			   LIBINPUT_EVENT_KEYBOARD_KEY);
+
+	return us2ms(event->time);
+}
+
+LIBINPUT_EXPORT uint64_t
+libinput_event_keyboard_get_time_usec(struct libinput_event_keyboard *event)
 {
 	require_event_type(libinput_event_get_context(&event->base),
 			   event->base.type,
@@ -323,6 +334,20 @@ libinput_event_keyboard_get_seat_key_count(
 
 LIBINPUT_EXPORT uint32_t
 libinput_event_pointer_get_time(struct libinput_event_pointer *event)
+{
+	require_event_type(libinput_event_get_context(&event->base),
+			   event->base.type,
+			   0,
+			   LIBINPUT_EVENT_POINTER_MOTION,
+			   LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE,
+			   LIBINPUT_EVENT_POINTER_BUTTON,
+			   LIBINPUT_EVENT_POINTER_AXIS);
+
+	return us2ms(event->time);
+}
+
+LIBINPUT_EXPORT uint64_t
+libinput_event_pointer_get_time_usec(struct libinput_event_pointer *event)
 {
 	require_event_type(libinput_event_get_context(&event->base),
 			   event->base.type,
@@ -561,6 +586,21 @@ libinput_event_pointer_get_axis_source(struct libinput_event_pointer *event)
 
 LIBINPUT_EXPORT uint32_t
 libinput_event_touch_get_time(struct libinput_event_touch *event)
+{
+	require_event_type(libinput_event_get_context(&event->base),
+			   event->base.type,
+			   0,
+			   LIBINPUT_EVENT_TOUCH_DOWN,
+			   LIBINPUT_EVENT_TOUCH_UP,
+			   LIBINPUT_EVENT_TOUCH_MOTION,
+			   LIBINPUT_EVENT_TOUCH_CANCEL,
+			   LIBINPUT_EVENT_TOUCH_FRAME);
+
+	return us2ms(event->time);
+}
+
+LIBINPUT_EXPORT uint64_t
+libinput_event_touch_get_time_usec(struct libinput_event_touch *event)
 {
 	require_event_type(libinput_event_get_context(&event->base),
 			   event->base.type,
@@ -666,6 +706,22 @@ libinput_event_touch_get_y(struct libinput_event_touch *event)
 
 LIBINPUT_EXPORT uint32_t
 libinput_event_gesture_get_time(struct libinput_event_gesture *event)
+{
+	require_event_type(libinput_event_get_context(&event->base),
+			   event->base.type,
+			   0,
+			   LIBINPUT_EVENT_GESTURE_PINCH_BEGIN,
+			   LIBINPUT_EVENT_GESTURE_PINCH_UPDATE,
+			   LIBINPUT_EVENT_GESTURE_PINCH_END,
+			   LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
+			   LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE,
+			   LIBINPUT_EVENT_GESTURE_SWIPE_END);
+
+	return us2ms(event->time);
+}
+
+LIBINPUT_EXPORT uint64_t
+libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event)
 {
 	require_event_type(libinput_event_get_context(&event->base),
 			   event->base.type,
diff --git a/src/libinput.h b/src/libinput.h
index f9a7d681..f2b77b34 100644
--- a/src/libinput.h
+++ b/src/libinput.h
@@ -418,6 +418,14 @@ libinput_event_device_notify_get_base_event(struct libinput_event_device_notify
 uint32_t
 libinput_event_keyboard_get_time(struct libinput_event_keyboard *event);
 
+/**
+ * @ingroup event_keyboard
+ *
+ * @return The event time for this event in microseconds
+ */
+uint64_t
+libinput_event_keyboard_get_time_usec(struct libinput_event_keyboard *event);
+
 /**
  * @ingroup event_keyboard
  *
@@ -473,6 +481,14 @@ libinput_event_keyboard_get_seat_key_count(
 uint32_t
 libinput_event_pointer_get_time(struct libinput_event_pointer *event);
 
+/**
+ * @ingroup event_pointer
+ *
+ * @return The event time for this event in microseconds
+ */
+uint64_t
+libinput_event_pointer_get_time_usec(struct libinput_event_pointer *event);
+
 /**
  * @ingroup event_pointer
  *
@@ -815,6 +831,14 @@ libinput_event_pointer_get_base_event(struct libinput_event_pointer *event);
 uint32_t
 libinput_event_touch_get_time(struct libinput_event_touch *event);
 
+/**
+ * @ingroup event_touch
+ *
+ * @return The event time for this event in microseconds
+ */
+uint64_t
+libinput_event_touch_get_time_usec(struct libinput_event_touch *event);
+
 /**
  * @ingroup event_touch
  *
@@ -967,6 +991,14 @@ libinput_event_touch_get_base_event(struct libinput_event_touch *event);
 uint32_t
 libinput_event_gesture_get_time(struct libinput_event_gesture *event);
 
+/**
+ * @ingroup event_gesture
+ *
+ * @return The event time for this event in microseconds
+ */
+uint64_t
+libinput_event_gesture_get_time_usec(struct libinput_event_gesture *event);
+
 /**
  * @ingroup event_gesture
  *
diff --git a/src/libinput.sym b/src/libinput.sym
index d7d12e40..7e0ef1c5 100644
--- a/src/libinput.sym
+++ b/src/libinput.sym
@@ -167,4 +167,8 @@ LIBINPUT_0.21.0 {
 	libinput_device_config_dwt_set_enabled;
 	libinput_device_config_dwt_get_enabled;
 	libinput_device_config_dwt_get_default_enabled;
+	libinput_event_gesture_get_time_usec;
+	libinput_event_keyboard_get_time_usec;
+	libinput_event_pointer_get_time_usec;
+	libinput_event_touch_get_time_usec;
 } LIBINPUT_0.20.0;
diff --git a/src/timer.c b/src/timer.c
index a945f788..5ad23f31 100644
--- a/src/timer.c
+++ b/src/timer.c
@@ -57,8 +57,8 @@ libinput_timer_arm_timer_fd(struct libinput *libinput)
 	}
 
 	if (earliest_expire != UINT64_MAX) {
-		its.it_value.tv_sec = earliest_expire / 1000;
-		its.it_value.tv_nsec = (earliest_expire % 1000) * 1000 * 1000;
+		its.it_value.tv_sec = earliest_expire / ms2us(1000);
+		its.it_value.tv_nsec = (earliest_expire % ms2us(1000)) * 1000;
 	}
 
 	r = timerfd_settime(libinput->timer.fd, TFD_TIMER_ABSTIME, &its, NULL);
@@ -74,7 +74,7 @@ libinput_timer_set(struct libinput_timer *timer, uint64_t expire)
 	if (expire < now)
 		log_bug_libinput(timer->libinput,
 				 "timer offset negative\n");
-	else if ((expire - now) > 5000ULL)
+	else if ((expire - now) > ms2us(5000))
 		log_bug_libinput(timer->libinput,
 				 "timer offset more than 5s, now %"
 				 PRIu64 " expire %" PRIu64 "\n",
diff --git a/src/timer.h b/src/timer.h
index b005fbb8..f8315cfe 100644
--- a/src/timer.h
+++ b/src/timer.h
@@ -33,7 +33,7 @@ struct libinput;
 struct libinput_timer {
 	struct libinput *libinput;
 	struct list link;
-	uint64_t expire; /* in absolute ms CLOCK_MONOTONIC */
+	uint64_t expire; /* in absolute us CLOCK_MONOTONIC */
 	void (*timer_func)(uint64_t now, void *timer_func_data);
 	void *timer_func_data;
 };
@@ -43,7 +43,7 @@ libinput_timer_init(struct libinput_timer *timer, struct libinput *libinput,
 		    void (*timer_func)(uint64_t now, void *timer_func_data),
 		    void *timer_func_data);
 
-/* Set timer expire time, in absolute ms CLOCK_MONOTONIC */
+/* Set timer expire time, in absolute us CLOCK_MONOTONIC */
 void
 libinput_timer_set(struct libinput_timer *timer, uint64_t expire);
 
diff --git a/test/gestures.c b/test/gestures.c
index b9d73257..3b7ba7bf 100644
--- a/test/gestures.c
+++ b/test/gestures.c
@@ -349,6 +349,41 @@ START_TEST(gestures_spread)
 }
 END_TEST
 
+START_TEST(gestures_time_usec)
+{
+	struct litest_device *dev = litest_current_device();
+	struct libinput *li = dev->libinput;
+	struct libinput_event *event;
+	struct libinput_event_gesture *gevent;
+
+	if (libevdev_get_num_slots(dev->evdev) < 3)
+		return;
+
+	litest_drain_events(li);
+
+	litest_touch_down(dev, 0, 40, 40);
+	litest_touch_down(dev, 1, 40, 50);
+	litest_touch_down(dev, 2, 40, 60);
+	libinput_dispatch(li);
+	litest_touch_move_three_touches(dev,
+					40, 40,
+					40, 50,
+					40, 60,
+					0, 30,
+					4, 2);
+
+	litest_wait_for_event(li);
+
+	event = libinput_get_event(li);
+	gevent = litest_is_gesture_event(event,
+					 LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN,
+					 3);
+	ck_assert_int_eq(libinput_event_gesture_get_time(gevent),
+			 libinput_event_gesture_get_time_usec(gevent) / 1000);
+	libinput_event_destroy(event);
+}
+END_TEST
+
 void
 litest_setup_tests(void)
 {
@@ -361,4 +396,6 @@ litest_setup_tests(void)
 	litest_add_ranged("gestures:swipe", gestures_swipe_3fg, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
 	litest_add_ranged("gestures:pinch", gestures_pinch, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
 	litest_add_ranged("gestures:pinch", gestures_spread, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH, &cardinals);
+
+	litest_add("gesture:time", gestures_time_usec, LITEST_TOUCHPAD, LITEST_SINGLE_TOUCH);
 }
diff --git a/test/keyboard.c b/test/keyboard.c
index 204d57c4..e9f3bcb1 100644
--- a/test/keyboard.c
+++ b/test/keyboard.c
@@ -311,6 +311,35 @@ START_TEST(keyboard_keys_bad_device)
 }
 END_TEST
 
+START_TEST(keyboard_time_usec)
+{
+	struct litest_device *dev = litest_current_device();
+	struct libinput *li = dev->libinput;
+	struct libinput_event_keyboard *kev;
+	struct libinput_event *event;
+
+	if (!libevdev_has_event_code(dev->evdev, EV_KEY, KEY_A))
+		return;
+
+	litest_drain_events(dev->libinput);
+
+	litest_keyboard_key(dev, KEY_A, true);
+
+	litest_wait_for_event(li);
+
+	event = libinput_get_event(li);
+	kev = litest_is_keyboard_event(event,
+				       KEY_A,
+				       LIBINPUT_KEY_STATE_PRESSED);
+
+	ck_assert_int_eq(libinput_event_keyboard_get_time(kev),
+			 libinput_event_keyboard_get_time_usec(kev) / 1000);
+
+	libinput_event_destroy(event);
+	litest_drain_events(dev->libinput);
+}
+END_TEST
+
 void
 litest_setup_tests(void)
 {
@@ -319,4 +348,5 @@ litest_setup_tests(void)
 	litest_add_no_device("keyboard:key counting", keyboard_key_auto_release);
 	litest_add("keyboard:keys", keyboard_has_key, LITEST_KEYS, LITEST_ANY);
 	litest_add("keyboard:keys", keyboard_keys_bad_device, LITEST_ANY, LITEST_ANY);
+	litest_add("keyboard:time", keyboard_time_usec, LITEST_KEYS, LITEST_ANY);
 }
diff --git a/test/misc.c b/test/misc.c
index 6412b3b1..89edb145 100644
--- a/test/misc.c
+++ b/test/misc.c
@@ -507,7 +507,7 @@ START_TEST(ratelimit_helpers)
 	unsigned int i, j;
 
 	/* 10 attempts every 100ms */
-	ratelimit_init(&rl, 100, 10);
+	ratelimit_init(&rl, ms2us(100), 10);
 
 	for (j = 0; j < 3; ++j) {
 		/* a burst of 9 attempts must succeed */
@@ -683,6 +683,16 @@ START_TEST(dimension_prop_parser)
 }
 END_TEST
 
+START_TEST(time_conversion)
+{
+	ck_assert_int_eq(us(10), 10);
+	ck_assert_int_eq(ns2us(10000), 10);
+	ck_assert_int_eq(ms2us(10), 10000);
+	ck_assert_int_eq(s2us(1), 1000000);
+	ck_assert_int_eq(us2ms(10000), 10);
+}
+END_TEST
+
 void
 litest_setup_tests(void)
 {
@@ -703,4 +713,5 @@ litest_setup_tests(void)
 	litest_add_no_device("misc:parser", wheel_click_parser);
 	litest_add_no_device("misc:parser", trackpoint_accel_parser);
 	litest_add_no_device("misc:parser", dimension_prop_parser);
+	litest_add_no_device("misc:time", time_conversion);
 }
diff --git a/test/pointer.c b/test/pointer.c
index 10b9fdc4..f711d385 100644
--- a/test/pointer.c
+++ b/test/pointer.c
@@ -1419,6 +1419,32 @@ START_TEST(middlebutton_default_disabled)
 }
 END_TEST
 
+START_TEST(pointer_time_usec)
+{
+	struct litest_device *dev = litest_current_device();
+	struct libinput *li = dev->libinput;
+	struct libinput_event_pointer *ptrev;
+	struct libinput_event *event;
+
+	litest_drain_events(dev->libinput);
+
+	litest_event(dev, EV_REL, REL_X, 1);
+	litest_event(dev, EV_REL, REL_Y, 1);
+	litest_event(dev, EV_SYN, SYN_REPORT, 0);
+
+	litest_wait_for_event(li);
+
+	event = libinput_get_event(li);
+	ptrev = litest_is_motion_event(event);
+
+	ck_assert_int_eq(libinput_event_pointer_get_time(ptrev),
+			 libinput_event_pointer_get_time_usec(ptrev) / 1000);
+
+	libinput_event_destroy(event);
+	litest_drain_events(dev->libinput);
+}
+END_TEST
+
 void
 litest_setup_tests(void)
 {
@@ -1466,4 +1492,6 @@ litest_setup_tests(void)
 	litest_add_for_device("pointer:middlebutton", middlebutton_default_alps, LITEST_ALPS_SEMI_MT);
 
 	litest_add_ranged("pointer:state", pointer_absolute_initial_state, LITEST_ABSOLUTE, LITEST_ANY, &axis_range);
+
+	litest_add("pointer:time", pointer_time_usec, LITEST_RELATIVE, LITEST_ANY);
 }
diff --git a/test/touch.c b/test/touch.c
index b519613d..eae8007c 100644
--- a/test/touch.c
+++ b/test/touch.c
@@ -652,6 +652,27 @@ START_TEST(touch_initial_state)
 }
 END_TEST
 
+START_TEST(touch_time_usec)
+{
+	struct litest_device *dev = litest_current_device();
+	struct libinput *li = dev->libinput;
+	struct libinput_event *event;
+	struct libinput_event_touch *tev;
+
+	litest_drain_events(dev->libinput);
+
+	litest_touch_down(dev, 0, 10, 10);
+
+	litest_wait_for_event(li);
+
+	event = libinput_get_event(li);
+	tev = litest_is_touch_event(event, LIBINPUT_EVENT_TOUCH_DOWN);
+	ck_assert_int_eq(libinput_event_touch_get_time(tev),
+			 libinput_event_touch_get_time_usec(tev) / 1000);
+	libinput_event_destroy(event);
+}
+END_TEST
+
 void
 litest_setup_tests(void)
 {
@@ -678,4 +699,6 @@ litest_setup_tests(void)
 	litest_add("touch:protocol a", touch_protocol_a_2fg_touch, LITEST_PROTOCOL_A, LITEST_ANY);
 
 	litest_add_ranged("touch:state", touch_initial_state, LITEST_TOUCH, LITEST_PROTOCOL_A, &axes);
+
+	litest_add("touch:time", touch_time_usec, LITEST_TOUCH, LITEST_TOUCHPAD);
 }
diff --git a/test/touchpad.c b/test/touchpad.c
index 5db79f8a..1935d19b 100644
--- a/test/touchpad.c
+++ b/test/touchpad.c
@@ -3458,6 +3458,40 @@ START_TEST(touchpad_tool_tripletap_touch_count)
 }
 END_TEST
 
+START_TEST(touchpad_time_usec)
+{
+	struct litest_device *dev = litest_current_device();
+	struct libinput *li = dev->libinput;
+	struct libinput_event *event;
+	struct libinput_event_pointer *ptrev;
+
+	litest_disable_tap(dev->libinput_device);
+
+	litest_drain_events(li);
+
+	litest_touch_down(dev, 0, 50, 50);
+	litest_touch_move_to(dev, 0, 50, 50, 80, 50, 5, 0);
+	litest_touch_up(dev, 0);
+
+	libinput_dispatch(li);
+
+	event = libinput_get_event(li);
+	ck_assert_notnull(event);
+
+	while (event) {
+		uint64_t utime;
+
+		ptrev = litest_is_motion_event(event);
+		utime = libinput_event_pointer_get_time_usec(ptrev);
+
+		ck_assert_int_eq(libinput_event_pointer_get_time(ptrev),
+				 utime / 1000);
+		libinput_event_destroy(event);
+		event = libinput_get_event(li);
+	}
+}
+END_TEST
+
 void
 litest_setup_tests(void)
 {
@@ -3562,4 +3596,6 @@ litest_setup_tests(void)
 	litest_add("touchpad:thumb", touchpad_thumb_tap_hold_2ndfg_tap, LITEST_CLICKPAD, LITEST_SINGLE_TOUCH);
 
 	litest_add_for_device("touchpad:bugs", touchpad_tool_tripletap_touch_count, LITEST_SYNAPTICS_TOPBUTTONPAD);
+
+	litest_add("touchpad:time", touchpad_time_usec, LITEST_TOUCHPAD, LITEST_ANY);
 }
diff --git a/tools/ptraccel-debug.c b/tools/ptraccel-debug.c
index b2dd1f90..1496763b 100644
--- a/tools/ptraccel-debug.c
+++ b/tools/ptraccel-debug.c
@@ -26,12 +26,14 @@
 #include <errno.h>
 #include <stdbool.h>
 #include <stdio.h>
-#include <filter.h>
 #include <getopt.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 
+#include <filter.h>
+#include <libinput-util.h>
+
 static void
 print_ptraccel_deltas(struct motion_filter *filter, double step)
 {
@@ -50,7 +52,7 @@ print_ptraccel_deltas(struct motion_filter *filter, double step)
 	for (i = 0.0; i < 15.0; i += step) {
 		motion.x = i;
 		motion.y = 0;
-		time += 12; /* pretend 80Hz data */
+		time += us(12500); /* pretend 80Hz data */
 
 		motion = filter_dispatch(filter, &motion, NULL, time);
 
@@ -93,7 +95,7 @@ print_ptraccel_movement(struct motion_filter *filter,
 	for (i = 0; i < nevents; i++) {
 		motion.x = dx;
 		motion.y = 0;
-		time += 12; /* pretend 80Hz data */
+		time += us(12500); /* pretend 80Hz data */
 
 		motion = filter_dispatch(filter, &motion, NULL, time);
 
@@ -127,7 +129,7 @@ print_ptraccel_sequence(struct motion_filter *filter,
 	for (i = 0; i < nevents; i++, dx++) {
 		motion.x = *dx;
 		motion.y = 0;
-		time += 12; /* pretend 80Hz data */
+		time += us(12500); /* pretend 80Hz data */
 
 		motion = filter_dispatch(filter, &motion, NULL, time);