diff --git a/drivers/adc/adc_ti_adc108s102.c b/drivers/adc/adc_ti_adc108s102.c
index a0d857ff200..abb0ca4af5b 100644
--- a/drivers/adc/adc_ti_adc108s102.c
+++ b/drivers/adc/adc_ti_adc108s102.c
@@ -186,7 +186,7 @@ static int ti_adc108s102_read(struct device *dev,
 
 		/* convert to milliseconds */
 		delay = (s32_t)((MSEC_PER_SEC * (u64_t)delay) /
-			sys_clock_ticks_per_sec);
+				sys_clock_ticks_per_sec());
 
 		k_sleep(delay);
 
diff --git a/drivers/sensor/dht/dht.c b/drivers/sensor/dht/dht.c
index 82aa467c123..a9eb73c8917 100644
--- a/drivers/sensor/dht/dht.c
+++ b/drivers/sensor/dht/dht.c
@@ -34,7 +34,7 @@ static s8_t dht_measure_signal_duration(struct dht_data *drv_data,
 	u32_t elapsed_cycles;
 	u32_t max_wait_cycles = (u32_t)(
 		(u64_t)DHT_SIGNAL_MAX_WAIT_DURATION *
-		(u64_t)sys_clock_hw_cycles_per_sec /
+		(u64_t)sys_clock_hw_cycles_per_sec() /
 		(u64_t)USEC_PER_SEC
 	);
 	u32_t start_cycles = k_cycle_get_32();
@@ -50,7 +50,7 @@ static s8_t dht_measure_signal_duration(struct dht_data *drv_data,
 
 	return (u64_t)elapsed_cycles *
 	       (u64_t)USEC_PER_SEC /
-	       (u64_t)sys_clock_hw_cycles_per_sec;
+	       (u64_t)sys_clock_hw_cycles_per_sec();
 }
 
 static int dht_sample_fetch(struct device *dev, enum sensor_channel chan)
diff --git a/drivers/timer/hpet.c b/drivers/timer/hpet.c
index ef364d99e5d..e5e57c57356 100644
--- a/drivers/timer/hpet.c
+++ b/drivers/timer/hpet.c
@@ -159,6 +159,7 @@
 #define HPET_IOAPIC_FLAGS  (IOAPIC_LEVEL | IOAPIC_LOW)
 #endif
 
+extern int z_clock_hw_cycles_per_sec;
 
 #ifdef CONFIG_INT_LATENCY_BENCHMARK
 static u32_t main_count_first_irq_value;
@@ -583,7 +584,7 @@ int _sys_clock_driver_init(struct device *device)
 	 * Get tick time (in femptoseconds).
 	 */
 
-	tickFempto = 1000000000000000ull / sys_clock_ticks_per_sec;
+	tickFempto = 1000000000000000ull / sys_clock_ticks_per_sec();
 
 	/*
 	 * This driver shall read the COUNTER_CLK_PERIOD value from the general
@@ -613,8 +614,8 @@ int _sys_clock_driver_init(struct device *device)
 	/* Initialize sys_clock_hw_cycles_per_tick/sec */
 
 	sys_clock_hw_cycles_per_tick = counter_load_value;
-	sys_clock_hw_cycles_per_sec = sys_clock_hw_cycles_per_tick *
-									sys_clock_ticks_per_sec;
+	z_clock_hw_cycles_per_sec = sys_clock_hw_cycles_per_tick *
+		sys_clock_ticks_per_sec();
 
 
 #ifdef CONFIG_INT_LATENCY_BENCHMARK
diff --git a/drivers/timer/loapic_timer.c b/drivers/timer/loapic_timer.c
index 6365c4238ad..fb829dc80ad 100644
--- a/drivers/timer/loapic_timer.c
+++ b/drivers/timer/loapic_timer.c
@@ -765,7 +765,7 @@ u32_t _timer_cycle_get_32(void)
 	u64_t tsc;
 
 	/* 64-bit math to avoid overflows */
-	tsc = _tsc_read() * (u64_t)sys_clock_hw_cycles_per_sec /
+	tsc = _tsc_read() * (u64_t)sys_clock_hw_cycles_per_sec() /
 		(u64_t) CONFIG_TSC_CYCLES_PER_SEC;
 	return (u32_t)tsc;
 #else
diff --git a/drivers/timer/native_posix_timer.c b/drivers/timer/native_posix_timer.c
index d0046e77c24..5758487aee4 100644
--- a/drivers/timer/native_posix_timer.c
+++ b/drivers/timer/native_posix_timer.c
@@ -103,7 +103,7 @@ int _sys_clock_driver_init(struct device *device)
 {
 	ARG_UNUSED(device);
 
-	tick_period = 1000000ul / sys_clock_ticks_per_sec;
+	tick_period = 1000000ul / sys_clock_ticks_per_sec();
 
 	hwtimer_enable(tick_period);
 
diff --git a/include/sys_clock.h b/include/sys_clock.h
index b9b0a6b0a69..3c72fdfc2cf 100644
--- a/include/sys_clock.h
+++ b/include/sys_clock.h
@@ -26,20 +26,30 @@ extern "C" {
 #include <toolchain.h>
 #include <zephyr/types.h>
 
+static inline int sys_clock_ticks_per_sec(void)
+{
+#ifdef CONFIG_TICKLESS_KERNEL
+	return 1000000 / (CONFIG_TICKLESS_KERNEL_TIME_UNIT_IN_MICRO_SECS);
+#else
+	return CONFIG_SYS_CLOCK_TICKS_PER_SEC;
+#endif
+}
+
 #ifdef CONFIG_TICKLESS_KERNEL
-#define sys_clock_ticks_per_sec \
-		(1000000 / (CONFIG_TICKLESS_KERNEL_TIME_UNIT_IN_MICRO_SECS))
 extern int _sys_clock_always_on;
 extern void _enable_sys_clock(void);
-#else
-#define sys_clock_ticks_per_sec CONFIG_SYS_CLOCK_TICKS_PER_SEC
 #endif
 
+static inline int sys_clock_hw_cycles_per_sec(void)
+{
 #if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
-extern int sys_clock_hw_cycles_per_sec;
+	extern int z_clock_hw_cycles_per_sec;
+
+	return z_clock_hw_cycles_per_sec;
 #else
-#define sys_clock_hw_cycles_per_sec CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC
+	return CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC;
 #endif
+}
 
 #if defined(CONFIG_SYS_CLOCK_EXISTS) && \
 	(CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC == 0)
@@ -74,9 +84,9 @@ extern int sys_clock_hw_cycles_per_sec;
  */
 
 #if !defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
-#if	(sys_clock_hw_cycles_per_sec % sys_clock_ticks_per_sec) != 0
+#if	(CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC % CONFIG_SYS_CLOCK_TICKS_PER_SEC) != 0
 	#define _NEED_PRECISE_TICK_MS_CONVERSION
-#elif	(MSEC_PER_SEC % sys_clock_ticks_per_sec) != 0
+#elif	(MSEC_PER_SEC % CONFIG_SYS_CLOCK_TICKS_PER_SEC) != 0
 	#define _NON_OPTIMIZED_TICKS_PER_SEC
 #endif
 #endif
@@ -94,12 +104,12 @@ static ALWAYS_INLINE s32_t _ms_to_ticks(s32_t ms)
 #ifdef _NEED_PRECISE_TICK_MS_CONVERSION
 	/* use 64-bit math to keep precision */
 	return (s32_t)ceiling_fraction(
-		(s64_t)ms * sys_clock_hw_cycles_per_sec,
-		((s64_t)MSEC_PER_SEC * sys_clock_hw_cycles_per_sec) /
-		sys_clock_ticks_per_sec);
+		(s64_t)ms * sys_clock_hw_cycles_per_sec(),
+		((s64_t)MSEC_PER_SEC * sys_clock_hw_cycles_per_sec()) /
+		sys_clock_ticks_per_sec());
 #else
 	/* simple division keeps precision */
-	s32_t ms_per_tick = MSEC_PER_SEC / sys_clock_ticks_per_sec;
+	s32_t ms_per_tick = MSEC_PER_SEC / sys_clock_ticks_per_sec();
 
 	return (s32_t)ceiling_fraction(ms, ms_per_tick);
 #endif
@@ -116,10 +126,10 @@ static inline s64_t __ticks_to_ms(s64_t ticks)
 
 #ifdef _NEED_PRECISE_TICK_MS_CONVERSION
 	/* use 64-bit math to keep precision */
-	return (u64_t)ticks * MSEC_PER_SEC / sys_clock_ticks_per_sec;
+	return (u64_t)ticks * MSEC_PER_SEC / sys_clock_ticks_per_sec();
 #else
 	/* simple multiplication keeps precision */
-	u32_t ms_per_tick = MSEC_PER_SEC / sys_clock_ticks_per_sec;
+	u32_t ms_per_tick = MSEC_PER_SEC / sys_clock_ticks_per_sec();
 
 	return (u64_t)ticks * ms_per_tick;
 #endif
@@ -155,7 +165,7 @@ extern int sys_clock_hw_cycles_per_tick;
 
 /* SYS_CLOCK_HW_CYCLES_TO_NS64 converts CPU clock cycles to nanoseconds */
 #define SYS_CLOCK_HW_CYCLES_TO_NS64(X) \
-	(((u64_t)(X) * NSEC_PER_SEC) / sys_clock_hw_cycles_per_sec)
+	(((u64_t)(X) * NSEC_PER_SEC) / sys_clock_hw_cycles_per_sec())
 
 /*
  * SYS_CLOCK_HW_CYCLES_TO_NS_AVG converts CPU clock cycles to nanoseconds
@@ -206,11 +216,11 @@ extern s32_t _timeout_remaining_get(struct _timeout *timeout);
 /*
  * Number of ticks for x seconds. NOTE: With MSEC() or USEC(),
  * since it does an integer division, x must be greater or equal to
- * 1000/sys_clock_ticks_per_sec to get a non-zero value.
+ * 1000/sys_clock_ticks_per_sec() to get a non-zero value.
  * You may want to raise CONFIG_SYS_CLOCK_TICKS_PER_SEC depending on
  * your requirements.
  */
-#define SECONDS(x)	((x) * sys_clock_ticks_per_sec)
+#define SECONDS(x)	((x) * sys_clock_ticks_per_sec())
 #define MSEC(x)		(SECONDS(x) / MSEC_PER_SEC)
 #define USEC(x)		(MSEC(x) / USEC_PER_MSEC)
 
diff --git a/kernel/sys_clock.c b/kernel/sys_clock.c
index dc2232fc318..f89780dae71 100644
--- a/kernel/sys_clock.c
+++ b/kernel/sys_clock.c
@@ -21,18 +21,16 @@
 #endif
 
 #ifdef CONFIG_SYS_CLOCK_EXISTS
-int sys_clock_us_per_tick = 1000000 / sys_clock_ticks_per_sec;
 int sys_clock_hw_cycles_per_tick =
-	CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC / sys_clock_ticks_per_sec;
+	CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC / CONFIG_SYS_CLOCK_TICKS_PER_SEC;
 #if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
-int sys_clock_hw_cycles_per_sec = CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC;
+int z_clock_hw_cycles_per_sec = CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC;
 #endif
 #else
 /* don't initialize to avoid division-by-zero error */
-int sys_clock_us_per_tick;
 int sys_clock_hw_cycles_per_tick;
 #if defined(CONFIG_TIMER_READS_ITS_FREQUENCY_AT_RUNTIME)
-int sys_clock_hw_cycles_per_sec;
+int z_clock_hw_cycles_per_sec;
 #endif
 #endif
 
diff --git a/kernel/thread.c b/kernel/thread.c
index b2fece49016..adf8b7f8385 100644
--- a/kernel/thread.c
+++ b/kernel/thread.c
@@ -104,7 +104,7 @@ int saved_always_on = k_enable_sys_clock_always_on();
 	/* use 64-bit math to prevent overflow when multiplying */
 	u32_t cycles_to_wait = (u32_t)(
 		(u64_t)usec_to_wait *
-		(u64_t)sys_clock_hw_cycles_per_sec /
+		(u64_t)sys_clock_hw_cycles_per_sec() /
 		(u64_t)USEC_PER_SEC
 	);
 	u32_t start_cycles = k_cycle_get_32();
diff --git a/samples/net/zperf/src/zperf_internal.h b/samples/net/zperf/src/zperf_internal.h
index 160929f31c6..7be27417e19 100644
--- a/samples/net/zperf/src/zperf_internal.h
+++ b/samples/net/zperf/src/zperf_internal.h
@@ -40,7 +40,7 @@
 #define HW_CYCLES_TO_USEC(__hw_cycle__) \
 	( \
 		((u64_t)(__hw_cycle__) * (u64_t)USEC_PER_SEC) / \
-		((u64_t)sys_clock_hw_cycles_per_sec) \
+		((u64_t)sys_clock_hw_cycles_per_sec())		\
 	)
 
 #define HW_CYCLES_TO_SEC(__hw_cycle__) \
@@ -51,7 +51,7 @@
 
 #define USEC_TO_HW_CYCLES(__usec__) \
 	( \
-		((u64_t)(__usec__) * (u64_t)sys_clock_hw_cycles_per_sec) / \
+	 ((u64_t)(__usec__) * (u64_t)sys_clock_hw_cycles_per_sec()) /	\
 		((u64_t)USEC_PER_SEC) \
 	)
 
diff --git a/tests/benchmarks/app_kernel/src/master.h b/tests/benchmarks/app_kernel/src/master.h
index 53148373e23..4c869f58454 100644
--- a/tests/benchmarks/app_kernel/src/master.h
+++ b/tests/benchmarks/app_kernel/src/master.h
@@ -35,10 +35,10 @@
 /* length of the output line */
 #define SLINE_LEN 256
 
-#define SLEEP_TIME ((sys_clock_ticks_per_sec / 4) > 0 ? \
-		    sys_clock_ticks_per_sec / 4 : 1)
-#define WAIT_TIME ((sys_clock_ticks_per_sec / 10) > 0 ? \
-		   sys_clock_ticks_per_sec / 10 : 1)
+#define SLEEP_TIME ((sys_clock_ticks_per_sec() / 4) > 0 ?	\
+		    sys_clock_ticks_per_sec() / 4 : 1)
+#define WAIT_TIME ((sys_clock_ticks_per_sec() / 10) > 0 ?	\
+		   sys_clock_ticks_per_sec() / 10 : 1)
 #define NR_OF_NOP_RUNS 10000
 #define NR_OF_FIFO_RUNS 500
 #define NR_OF_SEMA_RUNS 500
@@ -48,7 +48,7 @@
 #define NR_OF_EVENT_RUNS  1000
 #define NR_OF_MBOX_RUNS 128
 #define NR_OF_PIPE_RUNS 256
-/* #define SEMA_WAIT_TIME (5 * sys_clock_ticks_per_sec) */
+/* #define SEMA_WAIT_TIME (5 * sys_clock_ticks_per_sec()) */
 #define SEMA_WAIT_TIME (5000)
 /* global data */
 extern char msg[MAX_MSG];
diff --git a/tests/kernel/common/src/clock.c b/tests/kernel/common/src/clock.c
index 9fba11f11af..3a94bd47577 100644
--- a/tests/kernel/common/src/clock.c
+++ b/tests/kernel/common/src/clock.c
@@ -124,7 +124,7 @@ void test_clock_cycle(void)
 	if (c1 > c0) {
 		/* delta cycle should be greater than 1 milli-second*/
 		zassert_true((c1 - c0) >
-			     (sys_clock_hw_cycles_per_sec / MSEC_PER_SEC), NULL);
+			     (sys_clock_hw_cycles_per_sec() / MSEC_PER_SEC), NULL);
 		/* delta NS should be greater than 1 milli-second */
 		zassert_true(SYS_CLOCK_HW_CYCLES_TO_NS(c1 - c0) >
 			     (NSEC_PER_SEC / MSEC_PER_SEC), NULL);
diff --git a/tests/kernel/mem_pool/mem_pool/src/main.c b/tests/kernel/mem_pool/mem_pool/src/main.c
index 3741adfdc6f..4c1f47cf370 100644
--- a/tests/kernel/mem_pool/mem_pool/src/main.c
+++ b/tests/kernel/mem_pool/mem_pool/src/main.c
@@ -22,8 +22,8 @@
 #include <tc_util.h>
 #include <misc/util.h>
 
-#define  ONE_SECOND     (sys_clock_ticks_per_sec)
-#define  TENTH_SECOND   (sys_clock_ticks_per_sec / 10)
+#define  ONE_SECOND     (CONFIG_SYS_CLOCK_TICKS_PER_SEC)
+#define  TENTH_SECOND   (CONFIG_SYS_CLOCK_TICKS_PER_SEC / 10)
 
 #define  NUM_BLOCKS     64
 
diff --git a/tests/kernel/timer/timer_monotonic/src/main.c b/tests/kernel/timer/timer_monotonic/src/main.c
index f49a78087b7..4fe138bde64 100644
--- a/tests/kernel/timer/timer_monotonic/src/main.c
+++ b/tests/kernel/timer/timer_monotonic/src/main.c
@@ -19,10 +19,10 @@ int test_frequency(void)
 	end = k_cycle_get_32();
 
 	delta = end - start;
-	pct = (u64_t)delta * 100 / sys_clock_hw_cycles_per_sec;
+	pct = (u64_t)delta * 100 / sys_clock_hw_cycles_per_sec();
 
 	printk("delta: %u  expected: %u  %u%%\n", delta,
-	       sys_clock_hw_cycles_per_sec, pct);
+	       sys_clock_hw_cycles_per_sec(), pct);
 
 	/* Heuristic: if we're more than 10% off, throw an error */
 	if (pct < 90 || pct > 110) {
@@ -45,7 +45,7 @@ int test_frequency(void)
  *
  * @ingroup kernel_timer_tests
  *
- * @see k_cycle_get_32(), sys_clock_hw_cycles_per_sec
+ * @see k_cycle_get_32(), sys_clock_hw_cycles_per_sec()
  */
 void test_timer(void)
 {
@@ -56,8 +56,8 @@ void test_timer(void)
 
 	TC_PRINT("sys_clock_hw_cycles_per_tick = %d\n",
 		 sys_clock_hw_cycles_per_tick);
-	TC_PRINT("sys_clock_hw_cycles_per_sec = %d\n",
-		 sys_clock_hw_cycles_per_sec);
+	TC_PRINT("sys_clock_hw_cycles_per_sec() = %d\n",
+		 sys_clock_hw_cycles_per_sec());
 
 	TC_START("test monotonic timer");
 
diff --git a/tests/ztest/include/ztest.h b/tests/ztest/include/ztest.h
index e5593e8f27a..4d7f897dbeb 100644
--- a/tests/ztest/include/ztest.h
+++ b/tests/ztest/include/ztest.h
@@ -39,6 +39,8 @@ extern "C" {
 #define CONFIG_NUM_COOP_PRIORITIES 16
 #define CONFIG_COOP_ENABLED 1
 #define CONFIG_PREEMPT_ENABLED 1
+#define CONFIG_SYS_CLOCK_TICKS_PER_SEC 100
+#define CONFIG_SYS_CLOCK_HW_CYCLES_PER_SEC 10000000
 /* FIXME: Properly integrate with Zephyr's arch specific code */
 #define CONFIG_X86 1
 #define PRINT printf