]> git.proxmox.com Git - mirror_edk2.git/blob - MdePkg/Library/DxeIoLibCpuIo2/IoLibMmioBuffer.c
UefiCpuPkg: Move AsmRelocateApLoopStart from Mpfuncs.nasm to AmdSev.nasm
[mirror_edk2.git] / MdePkg / Library / DxeIoLibCpuIo2 / IoLibMmioBuffer.c
1 /** @file
2 I/O Library MMIO Buffer Functions.
3
4 Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
5 SPDX-License-Identifier: BSD-2-Clause-Patent
6
7 **/
8
9 #include "DxeCpuIo2LibInternal.h"
10
11 /**
12 Copy data from MMIO region to system memory by using 8-bit access.
13
14 Copy data from MMIO region specified by starting address StartAddress
15 to system memory specified by Buffer by using 8-bit access. The total
16 number of byte to be copied is specified by Length. Buffer is returned.
17
18 If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
19 If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
20
21
22 @param StartAddress The starting address for the MMIO region to be copied from.
23 @param Length The size in bytes of the copy.
24 @param Buffer The pointer to a system memory buffer receiving the data read.
25
26 @return Buffer
27
28 **/
29 UINT8 *
30 EFIAPI
31 MmioReadBuffer8 (
32 IN UINTN StartAddress,
33 IN UINTN Length,
34 OUT UINT8 *Buffer
35 )
36 {
37 UINT8 *ReturnBuffer;
38
39 ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));
40 ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
41
42 ReturnBuffer = Buffer;
43
44 while (Length-- > 0) {
45 *(Buffer++) = MmioRead8 (StartAddress++);
46 }
47
48 return ReturnBuffer;
49 }
50
51 /**
52 Copy data from MMIO region to system memory by using 16-bit access.
53
54 Copy data from MMIO region specified by starting address StartAddress
55 to system memory specified by Buffer by using 16-bit access. The total
56 number of byte to be copied is specified by Length. Buffer is returned.
57
58 If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
59
60 If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
61 If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
62
63 If Length is not aligned on a 16-bit boundary, then ASSERT().
64
65 If Buffer is not aligned on a 16-bit boundary, then ASSERT().
66
67 @param StartAddress The starting address for the MMIO region to be copied from.
68 @param Length The size in bytes of the copy.
69 @param Buffer The pointer to a system memory buffer receiving the data read.
70
71 @return Buffer.
72
73 **/
74 UINT16 *
75 EFIAPI
76 MmioReadBuffer16 (
77 IN UINTN StartAddress,
78 IN UINTN Length,
79 OUT UINT16 *Buffer
80 )
81 {
82 UINT16 *ReturnBuffer;
83
84 ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
85
86 ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));
87 ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
88
89 ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
90 ASSERT (((UINTN)Buffer & (sizeof (UINT16) - 1)) == 0);
91
92 ReturnBuffer = Buffer;
93
94 while (Length > 0) {
95 *(Buffer++) = MmioRead16 (StartAddress);
96 StartAddress += sizeof (UINT16);
97 Length -= sizeof (UINT16);
98 }
99
100 return ReturnBuffer;
101 }
102
103 /**
104 Copy data from MMIO region to system memory by using 32-bit access.
105
106 Copy data from MMIO region specified by starting address StartAddress
107 to system memory specified by Buffer by using 32-bit access. The total
108 number of byte to be copied is specified by Length. Buffer is returned.
109
110 If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
111
112 If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
113 If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
114
115 If Length is not aligned on a 32-bit boundary, then ASSERT().
116 If Buffer is not aligned on a 32-bit boundary, then ASSERT().
117
118 @param StartAddress The starting address for the MMIO region to be copied from.
119 @param Length The size in bytes of the copy.
120 @param Buffer The pointer to a system memory buffer receiving the data read.
121
122 @return Buffer.
123
124 **/
125 UINT32 *
126 EFIAPI
127 MmioReadBuffer32 (
128 IN UINTN StartAddress,
129 IN UINTN Length,
130 OUT UINT32 *Buffer
131 )
132 {
133 UINT32 *ReturnBuffer;
134
135 ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
136
137 ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));
138 ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
139
140 ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
141 ASSERT (((UINTN)Buffer & (sizeof (UINT32) - 1)) == 0);
142
143 ReturnBuffer = Buffer;
144
145 while (Length > 0) {
146 *(Buffer++) = MmioRead32 (StartAddress);
147 StartAddress += sizeof (UINT32);
148 Length -= sizeof (UINT32);
149 }
150
151 return ReturnBuffer;
152 }
153
154 /**
155 Copy data from MMIO region to system memory by using 64-bit access.
156
157 Copy data from MMIO region specified by starting address StartAddress
158 to system memory specified by Buffer by using 64-bit access. The total
159 number of byte to be copied is specified by Length. Buffer is returned.
160
161 If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
162
163 If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
164 If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
165
166 If Length is not aligned on a 64-bit boundary, then ASSERT().
167
168 If Buffer is not aligned on a 64-bit boundary, then ASSERT().
169
170 @param StartAddress The starting address for the MMIO region to be copied from.
171 @param Length The size in bytes of the copy.
172 @param Buffer The pointer to a system memory buffer receiving the data read.
173
174 @return Buffer.
175
176 **/
177 UINT64 *
178 EFIAPI
179 MmioReadBuffer64 (
180 IN UINTN StartAddress,
181 IN UINTN Length,
182 OUT UINT64 *Buffer
183 )
184 {
185 UINT64 *ReturnBuffer;
186
187 ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
188
189 ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));
190 ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
191
192 ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
193 ASSERT (((UINTN)Buffer & (sizeof (UINT64) - 1)) == 0);
194
195 ReturnBuffer = Buffer;
196
197 while (Length > 0) {
198 *(Buffer++) = MmioRead64 (StartAddress);
199 StartAddress += sizeof (UINT64);
200 Length -= sizeof (UINT64);
201 }
202
203 return ReturnBuffer;
204 }
205
206 /**
207 Copy data from system memory to MMIO region by using 8-bit access.
208
209 Copy data from system memory specified by Buffer to MMIO region specified
210 by starting address StartAddress by using 8-bit access. The total number
211 of byte to be copied is specified by Length. Buffer is returned.
212
213 If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
214 If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
215
216
217 @param StartAddress The starting address for the MMIO region to be copied to.
218 @param Length The size in bytes of the copy.
219 @param Buffer The pointer to a system memory buffer containing the data to write.
220
221 @return Buffer.
222
223 **/
224 UINT8 *
225 EFIAPI
226 MmioWriteBuffer8 (
227 IN UINTN StartAddress,
228 IN UINTN Length,
229 IN CONST UINT8 *Buffer
230 )
231 {
232 VOID *ReturnBuffer;
233
234 ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));
235 ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
236
237 ReturnBuffer = (UINT8 *)Buffer;
238
239 while (Length-- > 0) {
240 MmioWrite8 (StartAddress++, *(Buffer++));
241 }
242
243 return ReturnBuffer;
244 }
245
246 /**
247 Copy data from system memory to MMIO region by using 16-bit access.
248
249 Copy data from system memory specified by Buffer to MMIO region specified
250 by starting address StartAddress by using 16-bit access. The total number
251 of byte to be copied is specified by Length. Buffer is returned.
252
253 If StartAddress is not aligned on a 16-bit boundary, then ASSERT().
254
255 If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
256 If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
257
258 If Length is not aligned on a 16-bit boundary, then ASSERT().
259
260 If Buffer is not aligned on a 16-bit boundary, then ASSERT().
261
262 @param StartAddress The starting address for the MMIO region to be copied to.
263 @param Length The size in bytes of the copy.
264 @param Buffer The pointer to a system memory buffer containing the data to write.
265
266 @return Buffer.
267
268 **/
269 UINT16 *
270 EFIAPI
271 MmioWriteBuffer16 (
272 IN UINTN StartAddress,
273 IN UINTN Length,
274 IN CONST UINT16 *Buffer
275 )
276 {
277 UINT16 *ReturnBuffer;
278
279 ASSERT ((StartAddress & (sizeof (UINT16) - 1)) == 0);
280
281 ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));
282 ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
283
284 ASSERT ((Length & (sizeof (UINT16) - 1)) == 0);
285 ASSERT (((UINTN)Buffer & (sizeof (UINT16) - 1)) == 0);
286
287 ReturnBuffer = (UINT16 *)Buffer;
288
289 while (Length > 0) {
290 MmioWrite16 (StartAddress, *(Buffer++));
291
292 StartAddress += sizeof (UINT16);
293 Length -= sizeof (UINT16);
294 }
295
296 return ReturnBuffer;
297 }
298
299 /**
300 Copy data from system memory to MMIO region by using 32-bit access.
301
302 Copy data from system memory specified by Buffer to MMIO region specified
303 by starting address StartAddress by using 32-bit access. The total number
304 of byte to be copied is specified by Length. Buffer is returned.
305
306 If StartAddress is not aligned on a 32-bit boundary, then ASSERT().
307
308 If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
309 If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
310
311 If Length is not aligned on a 32-bit boundary, then ASSERT().
312
313 If Buffer is not aligned on a 32-bit boundary, then ASSERT().
314
315 @param StartAddress The starting address for the MMIO region to be copied to.
316 @param Length The size in bytes of the copy.
317 @param Buffer The pointer to a system memory buffer containing the data to write.
318
319 @return Buffer.
320
321 **/
322 UINT32 *
323 EFIAPI
324 MmioWriteBuffer32 (
325 IN UINTN StartAddress,
326 IN UINTN Length,
327 IN CONST UINT32 *Buffer
328 )
329 {
330 UINT32 *ReturnBuffer;
331
332 ASSERT ((StartAddress & (sizeof (UINT32) - 1)) == 0);
333
334 ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));
335 ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
336
337 ASSERT ((Length & (sizeof (UINT32) - 1)) == 0);
338 ASSERT (((UINTN)Buffer & (sizeof (UINT32) - 1)) == 0);
339
340 ReturnBuffer = (UINT32 *)Buffer;
341
342 while (Length > 0) {
343 MmioWrite32 (StartAddress, *(Buffer++));
344
345 StartAddress += sizeof (UINT32);
346 Length -= sizeof (UINT32);
347 }
348
349 return ReturnBuffer;
350 }
351
352 /**
353 Copy data from system memory to MMIO region by using 64-bit access.
354
355 Copy data from system memory specified by Buffer to MMIO region specified
356 by starting address StartAddress by using 64-bit access. The total number
357 of byte to be copied is specified by Length. Buffer is returned.
358
359 If StartAddress is not aligned on a 64-bit boundary, then ASSERT().
360
361 If Length is greater than (MAX_ADDRESS - StartAddress + 1), then ASSERT().
362 If Length is greater than (MAX_ADDRESS -Buffer + 1), then ASSERT().
363
364 If Length is not aligned on a 64-bit boundary, then ASSERT().
365
366 If Buffer is not aligned on a 64-bit boundary, then ASSERT().
367
368 @param StartAddress The starting address for the MMIO region to be copied to.
369 @param Length The size in bytes of the copy.
370 @param Buffer The pointer to a system memory buffer containing the data to write.
371
372 @return Buffer.
373
374 **/
375 UINT64 *
376 EFIAPI
377 MmioWriteBuffer64 (
378 IN UINTN StartAddress,
379 IN UINTN Length,
380 IN CONST UINT64 *Buffer
381 )
382 {
383 UINT64 *ReturnBuffer;
384
385 ASSERT ((StartAddress & (sizeof (UINT64) - 1)) == 0);
386
387 ASSERT ((Length - 1) <= (MAX_ADDRESS - StartAddress));
388 ASSERT ((Length - 1) <= (MAX_ADDRESS - (UINTN)Buffer));
389
390 ASSERT ((Length & (sizeof (UINT64) - 1)) == 0);
391 ASSERT (((UINTN)Buffer & (sizeof (UINT64) - 1)) == 0);
392
393 ReturnBuffer = (UINT64 *)Buffer;
394
395 while (Length > 0) {
396 MmioWrite64 (StartAddress, *(Buffer++));
397
398 StartAddress += sizeof (UINT64);
399 Length -= sizeof (UINT64);
400 }
401
402 return ReturnBuffer;
403 }