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