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