blob: ca961c3935221eb0aeeed716c9a40fef6da80c14 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/* Copyright 2013-2014 IBM Corp.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
* implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <timebase.h>
#include <opal.h>
#include <cpu.h>
#include <chip.h>
unsigned long tb_hz = 512000000;
static void time_wait_poll(unsigned long duration)
{
unsigned long now = mftb();
unsigned long end = now + duration;
unsigned long period = msecs_to_tb(5);
if (this_cpu()->tb_invalid) {
cpu_relax();
return;
}
while (tb_compare(now, end) != TB_AAFTERB) {
unsigned long remaining = end - now;
/* Call pollers periodically but not continually to avoid
* bouncing cachelines due to lock contention. */
if (remaining >= period) {
opal_run_pollers();
time_wait_nopoll(period);
remaining -= period;
} else
time_wait_nopoll(remaining);
now = mftb();
}
}
void time_wait(unsigned long duration)
{
struct cpu_thread *c = this_cpu();
if (this_cpu()->lock_depth) {
time_wait_nopoll(duration);
return;
}
if (c != boot_cpu)
time_wait_nopoll(duration);
else
time_wait_poll(duration);
}
void time_wait_nopoll(unsigned long duration)
{
unsigned long min_sleep = usecs_to_tb(10);
if (this_cpu()->tb_invalid) {
cpu_relax();
return;
}
cpu_idle_delay(duration, min_sleep);
}
void time_wait_ms(unsigned long ms)
{
time_wait(msecs_to_tb(ms));
}
void time_wait_ms_nopoll(unsigned long ms)
{
time_wait_nopoll(msecs_to_tb(ms));
}
void time_wait_us(unsigned long us)
{
time_wait(usecs_to_tb(us));
}
void time_wait_us_nopoll(unsigned long us)
{
time_wait_nopoll(usecs_to_tb(us));
}
unsigned long timespec_to_tb(const struct timespec *ts)
{
unsigned long ns;
/* First convert to ns */
ns = ts->tv_sec * 1000000000ul;
ns += ts->tv_nsec;
/*
* This is a very rough approximation, it works provided
* we never try to pass too long delays here and the TB
* frequency isn't significantly lower than 512Mhz.
*
* We could improve the precision by shifting less bits
* at the expense of capacity or do 128 bit math which
* I'm not eager to do :-)
*/
if (chip_quirk(QUIRK_SLOW_SIM))
return (ns * (tb_hz >> 16)) / (1000000000ul >> 16);
else
return (ns * (tb_hz >> 24)) / (1000000000ul >> 24);
}
int nanosleep(const struct timespec *req, struct timespec *rem)
{
time_wait(timespec_to_tb(req));
if (rem) {
rem->tv_sec = 0;
rem->tv_nsec = 0;
}
return 0;
}
int nanosleep_nopoll(const struct timespec *req, struct timespec *rem)
{
time_wait_nopoll(timespec_to_tb(req));
if (rem) {
rem->tv_sec = 0;
rem->tv_nsec = 0;
}
return 0;
}
|
