1/*
  2 * Copyright 2012 Tilera Corporation. All Rights Reserved.
  3 *
  4 *   This program is free software; you can redistribute it and/or
  5 *   modify it under the terms of the GNU General Public License
  6 *   as published by the Free Software Foundation, version 2.
  7 *
  8 *   This program is distributed in the hope that it will be useful, but
  9 *   WITHOUT ANY WARRANTY; without even the implied warranty of
 10 *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
 11 *   NON INFRINGEMENT.  See the GNU General Public License for
 12 *   more details.
 13 */
 14
 15#define VDSO_BUILD  /* avoid some shift warnings for -m32 in <asm/page.h> */
 16#include <linux/time.h>
 17#include <asm/timex.h>
 18#include <asm/unistd.h>
 19#include <asm/vdso.h>
 20
 21#if CHIP_HAS_SPLIT_CYCLE()
 22static inline cycles_t get_cycles_inline(void)
 23{
 24	unsigned int high = __insn_mfspr(SPR_CYCLE_HIGH);
 25	unsigned int low = __insn_mfspr(SPR_CYCLE_LOW);
 26	unsigned int high2 = __insn_mfspr(SPR_CYCLE_HIGH);
 27
 28	while (unlikely(high != high2)) {
 29		low = __insn_mfspr(SPR_CYCLE_LOW);
 30		high = high2;
 31		high2 = __insn_mfspr(SPR_CYCLE_HIGH);
 32	}
 33
 34	return (((cycles_t)high) << 32) | low;
 35}
 36#define get_cycles get_cycles_inline
 37#endif
 38
 39struct syscall_return_value {
 40	long value;
 41	long error;
 42};
 43
 44/*
 45 * Find out the vDSO data page address in the process address space.
 46 */
 47inline unsigned long get_datapage(void)
 48{
 49	unsigned long ret;
 50
 51	/* vdso data page located in the 2nd vDSO page. */
 52	asm volatile ("lnk %0" : "=r"(ret));
 53	ret &= ~(PAGE_SIZE - 1);
 54	ret += PAGE_SIZE;
 55
 56	return ret;
 57}
 58
 59static inline u64 vgetsns(struct vdso_data *vdso)
 60{
 61	return ((get_cycles() - vdso->cycle_last) & vdso->mask) * vdso->mult;
 62}
 63
 64static inline int do_realtime(struct vdso_data *vdso, struct timespec *ts)
 65{
 66	unsigned count;
 67	u64 ns;
 68
 69	do {
 70		count = raw_read_seqcount_begin(&vdso->tb_seq);
 71		ts->tv_sec = vdso->wall_time_sec;
 72		ns = vdso->wall_time_snsec;
 73		ns += vgetsns(vdso);
 74		ns >>= vdso->shift;
 75	} while (unlikely(read_seqcount_retry(&vdso->tb_seq, count)));
 76
 77	ts->tv_sec += __iter_div_u64_rem(ns, NSEC_PER_SEC, &ns);
 78	ts->tv_nsec = ns;
 79
 80	return 0;
 81}
 82
 83static inline int do_monotonic(struct vdso_data *vdso, struct timespec *ts)
 84{
 85	unsigned count;
 86	u64 ns;
 87
 88	do {
 89		count = raw_read_seqcount_begin(&vdso->tb_seq);
 90		ts->tv_sec = vdso->monotonic_time_sec;
 91		ns = vdso->monotonic_time_snsec;
 92		ns += vgetsns(vdso);
 93		ns >>= vdso->shift;
 94	} while (unlikely(read_seqcount_retry(&vdso->tb_seq, count)));
 95
 96	ts->tv_sec += __iter_div_u64_rem(ns, NSEC_PER_SEC, &ns);
 97	ts->tv_nsec = ns;
 98
 99	return 0;
100}
101
102static inline int do_realtime_coarse(struct vdso_data *vdso,
103				     struct timespec *ts)
104{
105	unsigned count;
106
107	do {
108		count = raw_read_seqcount_begin(&vdso->tb_seq);
109		ts->tv_sec = vdso->wall_time_coarse_sec;
110		ts->tv_nsec = vdso->wall_time_coarse_nsec;
111	} while (unlikely(read_seqcount_retry(&vdso->tb_seq, count)));
112
113	return 0;
114}
115
116static inline int do_monotonic_coarse(struct vdso_data *vdso,
117				      struct timespec *ts)
118{
119	unsigned count;
120
121	do {
122		count = raw_read_seqcount_begin(&vdso->tb_seq);
123		ts->tv_sec = vdso->monotonic_time_coarse_sec;
124		ts->tv_nsec = vdso->monotonic_time_coarse_nsec;
125	} while (unlikely(read_seqcount_retry(&vdso->tb_seq, count)));
126
127	return 0;
128}
129
130struct syscall_return_value __vdso_gettimeofday(struct timeval *tv,
131						struct timezone *tz)
132{
133	struct syscall_return_value ret = { 0, 0 };
134	unsigned count;
135	struct vdso_data *vdso = (struct vdso_data *)get_datapage();
136
137	/* The use of the timezone is obsolete, normally tz is NULL. */
138	if (unlikely(tz != NULL)) {
139		do {
140			count = raw_read_seqcount_begin(&vdso->tz_seq);
141			tz->tz_minuteswest = vdso->tz_minuteswest;
142			tz->tz_dsttime = vdso->tz_dsttime;
143		} while (unlikely(read_seqcount_retry(&vdso->tz_seq, count)));
144	}
145
146	if (unlikely(tv == NULL))
147		return ret;
148
149	do_realtime(vdso, (struct timespec *)tv);
150	tv->tv_usec /= 1000;
151
152	return ret;
153}
154
155int gettimeofday(struct timeval *tv, struct timezone *tz)
156	__attribute__((weak, alias("__vdso_gettimeofday")));
157
158static struct syscall_return_value vdso_fallback_gettime(long clock,
159							 struct timespec *ts)
160{
161	struct syscall_return_value ret;
162	__asm__ __volatile__ (
163		"swint1"
164		: "=R00" (ret.value), "=R01" (ret.error)
165		: "R10" (__NR_clock_gettime), "R00" (clock), "R01" (ts)
166		: "r2", "r3", "r4", "r5", "r6", "r7",
167		"r8",  "r9", "r11", "r12", "r13", "r14", "r15",
168		"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
169		"r24", "r25", "r26", "r27", "r28", "r29", "memory");
170	return ret;
171}
172
173struct syscall_return_value __vdso_clock_gettime(clockid_t clock,
174						 struct timespec *ts)
175{
176	struct vdso_data *vdso = (struct vdso_data *)get_datapage();
177	struct syscall_return_value ret = { 0, 0 };
178
179	switch (clock) {
180	case CLOCK_REALTIME:
181		do_realtime(vdso, ts);
182		return ret;
183	case CLOCK_MONOTONIC:
184		do_monotonic(vdso, ts);
185		return ret;
186	case CLOCK_REALTIME_COARSE:
187		do_realtime_coarse(vdso, ts);
188		return ret;
189	case CLOCK_MONOTONIC_COARSE:
190		do_monotonic_coarse(vdso, ts);
191		return ret;
192	default:
193		return vdso_fallback_gettime(clock, ts);
194	}
195}
196
197int clock_gettime(clockid_t clock, struct timespec *ts)
198	__attribute__((weak, alias("__vdso_clock_gettime")));