1 /*
2  * Copyright (C) 2018 ARM Limited
3  * Copyright (C) 2015 Imagination Technologies
4  * Author: Alex Smith <alex.smith@imgtec.com>
5  *
6  * This program is free software; you can redistribute it and/or modify it
7  * under the terms of the GNU General Public License as published by the
8  * Free Software Foundation;  either version 2 of the  License, or (at your
9  * option) any later version.
10  */
11 #ifndef __ASM_VDSO_GETTIMEOFDAY_H
12 #define __ASM_VDSO_GETTIMEOFDAY_H
13 
14 #ifndef __ASSEMBLY__
15 
16 #include <asm/vdso/vdso.h>
17 #include <asm/clocksource.h>
18 #include <asm/unistd.h>
19 #include <asm/vdso.h>
20 
21 #define VDSO_HAS_CLOCK_GETRES		1
22 
23 static __always_inline long gettimeofday_fallback(
24 				struct __kernel_old_timeval *_tv,
25 				struct timezone *_tz)
26 {
27 	register struct timezone *tz asm("a1") = _tz;
28 	register struct __kernel_old_timeval *tv asm("a0") = _tv;
29 	register long ret asm("v0");
30 	register long nr asm("v0") = __NR_gettimeofday;
31 	register long error asm("a3");
32 
33 	asm volatile(
34 	"       syscall\n"
35 	: "=r" (ret), "=r" (error)
36 	: "r" (tv), "r" (tz), "r" (nr)
37 	: "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13",
38 	  "$14", "$15", "$24", "$25", "hi", "lo", "memory");
39 
40 	return error ? -ret : ret;
41 }
42 
43 static __always_inline long clock_gettime_fallback(
44 					clockid_t _clkid,
45 					struct __kernel_timespec *_ts)
46 {
47 	register struct __kernel_timespec *ts asm("a1") = _ts;
48 	register clockid_t clkid asm("a0") = _clkid;
49 	register long ret asm("v0");
50 #if _MIPS_SIM == _MIPS_SIM_ABI64
51 	register long nr asm("v0") = __NR_clock_gettime;
52 #else
53 	register long nr asm("v0") = __NR_clock_gettime64;
54 #endif
55 	register long error asm("a3");
56 
57 	asm volatile(
58 	"       syscall\n"
59 	: "=r" (ret), "=r" (error)
60 	: "r" (clkid), "r" (ts), "r" (nr)
61 	: "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13",
62 	  "$14", "$15", "$24", "$25", "hi", "lo", "memory");
63 
64 	return error ? -ret : ret;
65 }
66 
67 static __always_inline int clock_getres_fallback(
68 					clockid_t _clkid,
69 					struct __kernel_timespec *_ts)
70 {
71 	register struct __kernel_timespec *ts asm("a1") = _ts;
72 	register clockid_t clkid asm("a0") = _clkid;
73 	register long ret asm("v0");
74 #if _MIPS_SIM == _MIPS_SIM_ABI64
75 	register long nr asm("v0") = __NR_clock_getres;
76 #else
77 	register long nr asm("v0") = __NR_clock_getres_time64;
78 #endif
79 	register long error asm("a3");
80 
81 	asm volatile(
82 	"       syscall\n"
83 	: "=r" (ret), "=r" (error)
84 	: "r" (clkid), "r" (ts), "r" (nr)
85 	: "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13",
86 	  "$14", "$15", "$24", "$25", "hi", "lo", "memory");
87 
88 	return error ? -ret : ret;
89 }
90 
91 #if _MIPS_SIM != _MIPS_SIM_ABI64
92 
93 static __always_inline long clock_gettime32_fallback(
94 					clockid_t _clkid,
95 					struct old_timespec32 *_ts)
96 {
97 	register struct old_timespec32 *ts asm("a1") = _ts;
98 	register clockid_t clkid asm("a0") = _clkid;
99 	register long ret asm("v0");
100 	register long nr asm("v0") = __NR_clock_gettime;
101 	register long error asm("a3");
102 
103 	asm volatile(
104 	"       syscall\n"
105 	: "=r" (ret), "=r" (error)
106 	: "r" (clkid), "r" (ts), "r" (nr)
107 	: "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13",
108 	  "$14", "$15", "$24", "$25", "hi", "lo", "memory");
109 
110 	return error ? -ret : ret;
111 }
112 
113 static __always_inline int clock_getres32_fallback(
114 					clockid_t _clkid,
115 					struct old_timespec32 *_ts)
116 {
117 	register struct old_timespec32 *ts asm("a1") = _ts;
118 	register clockid_t clkid asm("a0") = _clkid;
119 	register long ret asm("v0");
120 	register long nr asm("v0") = __NR_clock_getres;
121 	register long error asm("a3");
122 
123 	asm volatile(
124 	"       syscall\n"
125 	: "=r" (ret), "=r" (error)
126 	: "r" (clkid), "r" (ts), "r" (nr)
127 	: "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13",
128 	  "$14", "$15", "$24", "$25", "hi", "lo", "memory");
129 
130 	return error ? -ret : ret;
131 }
132 #endif
133 
134 #ifdef CONFIG_CSRC_R4K
135 
136 static __always_inline u64 read_r4k_count(void)
137 {
138 	unsigned int count;
139 
140 	__asm__ __volatile__(
141 	"	.set push\n"
142 	"	.set mips32r2\n"
143 	"	rdhwr	%0, $2\n"
144 	"	.set pop\n"
145 	: "=r" (count));
146 
147 	return count;
148 }
149 
150 #endif
151 
152 #ifdef CONFIG_CLKSRC_MIPS_GIC
153 
154 static __always_inline u64 read_gic_count(const struct vdso_data *data)
155 {
156 	void __iomem *gic = get_gic(data);
157 	u32 hi, hi2, lo;
158 
159 	do {
160 		hi = __raw_readl(gic + sizeof(lo));
161 		lo = __raw_readl(gic);
162 		hi2 = __raw_readl(gic + sizeof(lo));
163 	} while (hi2 != hi);
164 
165 	return (((u64)hi) << 32) + lo;
166 }
167 
168 #endif
169 
170 static __always_inline u64 __arch_get_hw_counter(s32 clock_mode)
171 {
172 #ifdef CONFIG_CSRC_R4K
173 	if (clock_mode == VDSO_CLOCKMODE_R4K)
174 		return read_r4k_count();
175 #endif
176 #ifdef CONFIG_CLKSRC_MIPS_GIC
177 	if (clock_mode == VDSO_CLOCKMODE_GIC)
178 		return read_gic_count(get_vdso_data());
179 #endif
180 	/*
181 	 * Core checks mode already. So this raced against a concurrent
182 	 * update. Return something. Core will do another round see the
183 	 * change and fallback to syscall.
184 	 */
185 	return 0;
186 }
187 
188 static inline bool mips_vdso_hres_capable(void)
189 {
190 	return IS_ENABLED(CONFIG_CSRC_R4K) ||
191 	       IS_ENABLED(CONFIG_CLKSRC_MIPS_GIC);
192 }
193 #define __arch_vdso_hres_capable mips_vdso_hres_capable
194 
195 static __always_inline const struct vdso_data *__arch_get_vdso_data(void)
196 {
197 	return get_vdso_data();
198 }
199 
200 #endif /* !__ASSEMBLY__ */
201 
202 #endif /* __ASM_VDSO_GETTIMEOFDAY_H */
203