Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
powerpc/io: Use standard barrier macros in io.c
io.c uses open-coded barriers. Update it to use the equivalent but in
macro form.
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Signed-off-by: Madhavan Srinivasan <maddy@linux.ibm.com>
Link: https://patch.msgid.link/20241218105523.416573-18-mpe@ellerman.id.au
authored by
Michael Ellerman
and committed by
Madhavan Srinivasan
1b52e091
76c7d430
+24
-18
+24
-18
arch/powerpc/kernel/io.c
+24
-18
arch/powerpc/kernel/io.c
···
31
31
32
32
if (unlikely(count <= 0))
33
33
return;
34
-
asm volatile("sync");
34
+
35
+
mb();
35
36
do {
36
37
tmp = *(const volatile u8 __force *)port;
37
38
eieio();
38
39
*tbuf++ = tmp;
39
40
} while (--count != 0);
40
-
asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
41
+
data_barrier(tmp);
41
42
}
42
43
EXPORT_SYMBOL(_insb);
43
44
···
48
47
49
48
if (unlikely(count <= 0))
50
49
return;
51
-
asm volatile("sync");
50
+
51
+
mb();
52
52
do {
53
53
*(volatile u8 __force *)port = *tbuf++;
54
54
} while (--count != 0);
55
-
asm volatile("sync");
55
+
mb();
56
56
}
57
57
EXPORT_SYMBOL(_outsb);
58
58
···
64
62
65
63
if (unlikely(count <= 0))
66
64
return;
67
-
asm volatile("sync");
65
+
66
+
mb();
68
67
do {
69
68
tmp = *(const volatile u16 __force *)port;
70
69
eieio();
71
70
*tbuf++ = tmp;
72
71
} while (--count != 0);
73
-
asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
72
+
data_barrier(tmp);
74
73
}
75
74
EXPORT_SYMBOL(_insw);
76
75
···
81
78
82
79
if (unlikely(count <= 0))
83
80
return;
84
-
asm volatile("sync");
81
+
82
+
mb();
85
83
do {
86
84
*(volatile u16 __force *)port = *tbuf++;
87
85
} while (--count != 0);
88
-
asm volatile("sync");
86
+
mb();
89
87
}
90
88
EXPORT_SYMBOL(_outsw);
91
89
···
97
93
98
94
if (unlikely(count <= 0))
99
95
return;
100
-
asm volatile("sync");
96
+
97
+
mb();
101
98
do {
102
99
tmp = *(const volatile u32 __force *)port;
103
100
eieio();
104
101
*tbuf++ = tmp;
105
102
} while (--count != 0);
106
-
asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
103
+
data_barrier(tmp);
107
104
}
108
105
EXPORT_SYMBOL(_insl);
109
106
···
114
109
115
110
if (unlikely(count <= 0))
116
111
return;
117
-
asm volatile("sync");
112
+
113
+
mb();
118
114
do {
119
115
*(volatile u32 __force *)port = *tbuf++;
120
116
} while (--count != 0);
121
-
asm volatile("sync");
117
+
mb();
122
118
}
123
119
EXPORT_SYMBOL(_outsl);
124
120
···
133
127
lc |= lc << 8;
134
128
lc |= lc << 16;
135
129
136
-
__asm__ __volatile__ ("sync" : : : "memory");
130
+
mb();
137
131
while(n && !IO_CHECK_ALIGN(p, 4)) {
138
132
*((volatile u8 *)p) = c;
139
133
p++;
···
149
143
p++;
150
144
n--;
151
145
}
152
-
__asm__ __volatile__ ("sync" : : : "memory");
146
+
mb();
153
147
}
154
148
EXPORT_SYMBOL(_memset_io);
155
149
···
158
152
{
159
153
void *vsrc = (void __force *) src;
160
154
161
-
__asm__ __volatile__ ("sync" : : : "memory");
155
+
mb();
162
156
while(n && (!IO_CHECK_ALIGN(vsrc, 4) || !IO_CHECK_ALIGN(dest, 4))) {
163
157
*((u8 *)dest) = *((volatile u8 *)vsrc);
164
158
eieio();
···
180
174
dest++;
181
175
n--;
182
176
}
183
-
__asm__ __volatile__ ("sync" : : : "memory");
177
+
mb();
184
178
}
185
179
EXPORT_SYMBOL(_memcpy_fromio);
186
180
···
188
182
{
189
183
void *vdest = (void __force *) dest;
190
184
191
-
__asm__ __volatile__ ("sync" : : : "memory");
185
+
mb();
192
186
while(n && (!IO_CHECK_ALIGN(vdest, 4) || !IO_CHECK_ALIGN(src, 4))) {
193
187
*((volatile u8 *)vdest) = *((u8 *)src);
194
188
src++;
···
207
201
vdest++;
208
202
n--;
209
203
}
210
-
__asm__ __volatile__ ("sync" : : : "memory");
204
+
mb();
211
205
}
212
206
EXPORT_SYMBOL(_memcpy_toio);