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 #if MIPS_ISA_REV < 6 24 #define VDSO_SYSCALL_CLOBBERS "hi", "lo", 25 #else 26 #define VDSO_SYSCALL_CLOBBERS 27 #endif 28 29 static __always_inline long gettimeofday_fallback( 30 struct __kernel_old_timeval *_tv, 31 struct timezone *_tz) 32 { 33 register struct timezone *tz asm("a1") = _tz; 34 register struct __kernel_old_timeval *tv asm("a0") = _tv; 35 register long ret asm("v0"); 36 register long nr asm("v0") = __NR_gettimeofday; 37 register long error asm("a3"); 38 39 asm volatile( 40 " syscall\n" 41 : "=r" (ret), "=r" (error) 42 : "r" (tv), "r" (tz), "r" (nr) 43 : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", 44 "$14", "$15", "$24", "$25", 45 VDSO_SYSCALL_CLOBBERS 46 "memory"); 47 48 return error ? -ret : ret; 49 } 50 51 static __always_inline long clock_gettime_fallback( 52 clockid_t _clkid, 53 struct __kernel_timespec *_ts) 54 { 55 register struct __kernel_timespec *ts asm("a1") = _ts; 56 register clockid_t clkid asm("a0") = _clkid; 57 register long ret asm("v0"); 58 #if _MIPS_SIM == _MIPS_SIM_ABI64 59 register long nr asm("v0") = __NR_clock_gettime; 60 #else 61 register long nr asm("v0") = __NR_clock_gettime64; 62 #endif 63 register long error asm("a3"); 64 65 asm volatile( 66 " syscall\n" 67 : "=r" (ret), "=r" (error) 68 : "r" (clkid), "r" (ts), "r" (nr) 69 : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", 70 "$14", "$15", "$24", "$25", 71 VDSO_SYSCALL_CLOBBERS 72 "memory"); 73 74 return error ? -ret : ret; 75 } 76 77 static __always_inline int clock_getres_fallback( 78 clockid_t _clkid, 79 struct __kernel_timespec *_ts) 80 { 81 register struct __kernel_timespec *ts asm("a1") = _ts; 82 register clockid_t clkid asm("a0") = _clkid; 83 register long ret asm("v0"); 84 #if _MIPS_SIM == _MIPS_SIM_ABI64 85 register long nr asm("v0") = __NR_clock_getres; 86 #else 87 register long nr asm("v0") = __NR_clock_getres_time64; 88 #endif 89 register long error asm("a3"); 90 91 asm volatile( 92 " syscall\n" 93 : "=r" (ret), "=r" (error) 94 : "r" (clkid), "r" (ts), "r" (nr) 95 : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", 96 "$14", "$15", "$24", "$25", 97 VDSO_SYSCALL_CLOBBERS 98 "memory"); 99 100 return error ? -ret : ret; 101 } 102 103 #if _MIPS_SIM != _MIPS_SIM_ABI64 104 105 static __always_inline long clock_gettime32_fallback( 106 clockid_t _clkid, 107 struct old_timespec32 *_ts) 108 { 109 register struct old_timespec32 *ts asm("a1") = _ts; 110 register clockid_t clkid asm("a0") = _clkid; 111 register long ret asm("v0"); 112 register long nr asm("v0") = __NR_clock_gettime; 113 register long error asm("a3"); 114 115 asm volatile( 116 " syscall\n" 117 : "=r" (ret), "=r" (error) 118 : "r" (clkid), "r" (ts), "r" (nr) 119 : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", 120 "$14", "$15", "$24", "$25", 121 VDSO_SYSCALL_CLOBBERS 122 "memory"); 123 124 return error ? -ret : ret; 125 } 126 127 static __always_inline int clock_getres32_fallback( 128 clockid_t _clkid, 129 struct old_timespec32 *_ts) 130 { 131 register struct old_timespec32 *ts asm("a1") = _ts; 132 register clockid_t clkid asm("a0") = _clkid; 133 register long ret asm("v0"); 134 register long nr asm("v0") = __NR_clock_getres; 135 register long error asm("a3"); 136 137 asm volatile( 138 " syscall\n" 139 : "=r" (ret), "=r" (error) 140 : "r" (clkid), "r" (ts), "r" (nr) 141 : "$1", "$3", "$8", "$9", "$10", "$11", "$12", "$13", 142 "$14", "$15", "$24", "$25", 143 VDSO_SYSCALL_CLOBBERS 144 "memory"); 145 146 return error ? -ret : ret; 147 } 148 #endif 149 150 #ifdef CONFIG_CSRC_R4K 151 152 static __always_inline u64 read_r4k_count(void) 153 { 154 unsigned int count; 155 156 __asm__ __volatile__( 157 " .set push\n" 158 " .set mips32r2\n" 159 " rdhwr %0, $2\n" 160 " .set pop\n" 161 : "=r" (count)); 162 163 return count; 164 } 165 166 #endif 167 168 #ifdef CONFIG_CLKSRC_MIPS_GIC 169 170 static __always_inline u64 read_gic_count(const struct vdso_data *data) 171 { 172 void __iomem *gic = get_gic(data); 173 u32 hi, hi2, lo; 174 175 do { 176 hi = __raw_readl(gic + sizeof(lo)); 177 lo = __raw_readl(gic); 178 hi2 = __raw_readl(gic + sizeof(lo)); 179 } while (hi2 != hi); 180 181 return (((u64)hi) << 32) + lo; 182 } 183 184 #endif 185 186 static __always_inline u64 __arch_get_hw_counter(s32 clock_mode, 187 const struct vdso_data *vd) 188 { 189 #ifdef CONFIG_CSRC_R4K 190 if (clock_mode == VDSO_CLOCKMODE_R4K) 191 return read_r4k_count(); 192 #endif 193 #ifdef CONFIG_CLKSRC_MIPS_GIC 194 if (clock_mode == VDSO_CLOCKMODE_GIC) 195 return read_gic_count(vd); 196 #endif 197 /* 198 * Core checks mode already. So this raced against a concurrent 199 * update. Return something. Core will do another round see the 200 * change and fallback to syscall. 201 */ 202 return 0; 203 } 204 205 static inline bool mips_vdso_hres_capable(void) 206 { 207 return IS_ENABLED(CONFIG_CSRC_R4K) || 208 IS_ENABLED(CONFIG_CLKSRC_MIPS_GIC); 209 } 210 #define __arch_vdso_hres_capable mips_vdso_hres_capable 211 212 static __always_inline const struct vdso_data *__arch_get_vdso_data(void) 213 { 214 return get_vdso_data(); 215 } 216 217 #endif /* !__ASSEMBLY__ */ 218 219 #endif /* __ASM_VDSO_GETTIMEOFDAY_H */ 220