1/** @file
2  Common I/O Library routines.
3
4  Copyright (c) 2006 - 2008, 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 "BaseIoLibIntrinsicInternal.h"
16
17/**
18  Reads a 64-bit I/O port.
19
20  Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
21  This function must guarantee that all I/O read and write operations are
22  serialized.
23
24  If 64-bit I/O port operations are not supported, then ASSERT().
25  If Port is not aligned on a 64-bit boundary, then ASSERT().
26
27  @param  Port  The I/O port to read.
28
29  @return The value read.
30
31**/
32UINT64
33EFIAPI
34IoRead64 (
35  IN      UINTN                     Port
36  )
37{
38  ASSERT (FALSE);
39  return 0;
40}
41
42/**
43  Writes a 64-bit I/O port.
44
45  Writes the 64-bit I/O port specified by Port with the value specified by Value
46  and returns Value. This function must guarantee that all I/O read and write
47  operations are serialized.
48
49  If 64-bit I/O port operations are not supported, then ASSERT().
50  If Port is not aligned on a 64-bit boundary, then ASSERT().
51
52  @param  Port  The I/O port to write.
53  @param  Value The value to write to the I/O port.
54
55  @return The value written the I/O port.
56
57**/
58UINT64
59EFIAPI
60IoWrite64 (
61  IN      UINTN                     Port,
62  IN      UINT64                    Value
63  )
64{
65  ASSERT (FALSE);
66  return 0;
67}
68
69
70/**
71  Reads an 8-bit MMIO register.
72
73  Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
74  returned. This function must guarantee that all MMIO read and write
75  operations are serialized.
76
77  If 8-bit MMIO register operations are not supported, then ASSERT().
78
79  @param  Address The MMIO register to read.
80
81  @return The value read.
82
83**/
84UINT8
85EFIAPI
86MmioRead8 (
87  IN      UINTN                     Address
88  )
89{
90  UINT8                             Value;
91
92  MemoryFence ();
93  Value = *(volatile UINT8*)Address;
94  MemoryFence ();
95
96  return Value;
97}
98
99/**
100  Writes an 8-bit MMIO register.
101
102  Writes the 8-bit MMIO register specified by Address with the value specified
103  by Value and returns Value. This function must guarantee that all MMIO read
104  and write operations are serialized.
105
106  If 8-bit MMIO register operations are not supported, then ASSERT().
107
108  @param  Address The MMIO register to write.
109  @param  Value   The value to write to the MMIO register.
110
111  @return Value.
112
113**/
114UINT8
115EFIAPI
116MmioWrite8 (
117  IN      UINTN                     Address,
118  IN      UINT8                     Value
119  )
120{
121  MemoryFence ();
122  *(volatile UINT8*)Address = Value;
123  MemoryFence ();
124
125  return Value;
126}
127
128/**
129  Reads a 16-bit MMIO register.
130
131  Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
132  returned. This function must guarantee that all MMIO read and write
133  operations are serialized.
134
135  If 16-bit MMIO register operations are not supported, then ASSERT().
136  If Address is not aligned on a 16-bit boundary, then ASSERT().
137
138  @param  Address The MMIO register to read.
139
140  @return The value read.
141
142**/
143UINT16
144EFIAPI
145MmioRead16 (
146  IN      UINTN                     Address
147  )
148{
149  UINT16                            Value;
150
151  ASSERT ((Address & 1) == 0);
152
153  MemoryFence ();
154  Value = *(volatile UINT16*)Address;
155  MemoryFence ();
156
157  return Value;
158}
159
160/**
161  Writes a 16-bit MMIO register.
162
163  Writes the 16-bit MMIO register specified by Address with the value specified
164  by Value and returns Value. This function must guarantee that all MMIO read
165  and write operations are serialized.
166
167  If 16-bit MMIO register operations are not supported, then ASSERT().
168  If Address is not aligned on a 16-bit boundary, then ASSERT().
169
170  @param  Address The MMIO register to write.
171  @param  Value   The value to write to the MMIO register.
172
173  @return Value.
174
175**/
176UINT16
177EFIAPI
178MmioWrite16 (
179  IN      UINTN                     Address,
180  IN      UINT16                    Value
181  )
182{
183  ASSERT ((Address & 1) == 0);
184
185  MemoryFence ();
186  *(volatile UINT16*)Address = Value;
187  MemoryFence ();
188
189  return Value;
190}
191
192/**
193  Reads a 32-bit MMIO register.
194
195  Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
196  returned. This function must guarantee that all MMIO read and write
197  operations are serialized.
198
199  If 32-bit MMIO register operations are not supported, then ASSERT().
200  If Address is not aligned on a 32-bit boundary, then ASSERT().
201
202  @param  Address The MMIO register to read.
203
204  @return The value read.
205
206**/
207UINT32
208EFIAPI
209MmioRead32 (
210  IN      UINTN                     Address
211  )
212{
213  UINT32                            Value;
214
215  ASSERT ((Address & 3) == 0);
216
217  MemoryFence ();
218  Value = *(volatile UINT32*)Address;
219  MemoryFence ();
220
221  return Value;
222}
223
224/**
225  Writes a 32-bit MMIO register.
226
227  Writes the 32-bit MMIO register specified by Address with the value specified
228  by Value and returns Value. This function must guarantee that all MMIO read
229  and write operations are serialized.
230
231  If 32-bit MMIO register operations are not supported, then ASSERT().
232  If Address is not aligned on a 32-bit boundary, then ASSERT().
233
234  @param  Address The MMIO register to write.
235  @param  Value   The value to write to the MMIO register.
236
237  @return Value.
238
239**/
240UINT32
241EFIAPI
242MmioWrite32 (
243  IN      UINTN                     Address,
244  IN      UINT32                    Value
245  )
246{
247  ASSERT ((Address & 3) == 0);
248
249  MemoryFence ();
250  *(volatile UINT32*)Address = Value;
251  MemoryFence ();
252
253  return Value;
254}
255
256/**
257  Reads a 64-bit MMIO register.
258
259  Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
260  returned. This function must guarantee that all MMIO read and write
261  operations are serialized.
262
263  If 64-bit MMIO register operations are not supported, then ASSERT().
264  If Address is not aligned on a 64-bit boundary, then ASSERT().
265
266  @param  Address The MMIO register to read.
267
268  @return The value read.
269
270**/
271UINT64
272EFIAPI
273MmioRead64 (
274  IN      UINTN                     Address
275  )
276{
277  UINT64                            Value;
278
279  ASSERT ((Address & 7) == 0);
280
281  MemoryFence ();
282  Value = *(volatile UINT64*)Address;
283  MemoryFence ();
284
285  return Value;
286}
287
288/**
289  Writes a 64-bit MMIO register.
290
291  Writes the 64-bit MMIO register specified by Address with the value specified
292  by Value and returns Value. This function must guarantee that all MMIO read
293  and write operations are serialized.
294
295  If 64-bit MMIO register operations are not supported, then ASSERT().
296  If Address is not aligned on a 64-bit boundary, then ASSERT().
297
298  @param  Address The MMIO register to write.
299  @param  Value   The value to write to the MMIO register.
300
301**/
302UINT64
303EFIAPI
304MmioWrite64 (
305  IN      UINTN                     Address,
306  IN      UINT64                    Value
307  )
308{
309  ASSERT ((Address & 7) == 0);
310
311  MemoryFence ();
312  *(volatile UINT64*)Address = Value;
313  MemoryFence ();
314
315  return Value;
316}
317
318