blob: 451e3710e21da9e4d1bd5ad1b31e10f586bc997a (
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
|
// SPDX-License-Identifier: Apache-2.0 OR GPL-2.0-or-later
/*
* Wait for things, by waiting for timebase to tick over
*
* Copyright 2013-2019 IBM Corp.
*/
#include <timebase.h>
#include <opal.h>
#include <cpu.h>
#include <chip.h>
#include <debug_descriptor.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) {
/*
* Run pollers to allow some backends to process response.
*
* In TOD failure case where TOD is unrecoverable, running
* pollers allows ipmi backend to deal with ipmi response
* from bmc and helps ipmi_queue_msg_sync() to get un-stuck.
* Thus it avoids linux kernel to hang during panic due to
* TOD failure.
*/
opal_run_pollers();
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);
} else
time_wait_nopoll(remaining);
now = mftb();
}
}
void time_wait(unsigned long duration)
{
struct cpu_thread *c = this_cpu();
if (!list_empty(&this_cpu()->locks_held)) {
time_wait_nopoll(duration);
return;
}
if (c != boot_cpu && opal_booting())
time_wait_nopoll(duration);
else
time_wait_poll(duration);
}
void time_wait_nopoll(unsigned long duration)
{
if (this_cpu()->tb_invalid) {
cpu_relax();
return;
}
cpu_idle_delay(duration);
}
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;
}
|
