MdePkg/DxeIoLibEsal: Add new Fifo routines in IoLib class
[mirror_edk2.git] / MdePkg / Library / SmmIoLibSmmCpuIo2 / IoLib.c
1 /** @file
2 I/O Library.
3 The implementation of I/O operation for this library instance
4 are based on EFI_CPU_IO_PROTOCOL.
5
6 Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
7 This program and the accompanying materials
8 are licensed and made available under the terms and conditions of the BSD License
9 which accompanies this distribution. The full text of the license may be found at
10 http://opensource.org/licenses/bsd-license.php.
11
12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
14
15 **/
16
17 #include "SmmCpuIoLibInternal.h"
18
19 /**
20 Reads registers in the EFI CPU I/O space.
21
22 Reads the I/O port specified by Port with registers width specified by Width.
23 The read value is returned. If such operations are not supported, then ASSERT().
24 This function must guarantee that all I/O read and write operations are serialized.
25
26 @param Port The base address of the I/O operation.
27 The caller is responsible for aligning the Address if required.
28 @param Width The width of the I/O operation.
29
30 @return Data read from registers in the EFI CPU I/O space.
31
32 **/
33 UINT64
34 EFIAPI
35 IoReadWorker (
36 IN UINTN Port,
37 IN EFI_SMM_IO_WIDTH Width
38 )
39 {
40 EFI_STATUS Status;
41 UINT64 Data;
42
43 Status = gSmst->SmmIo.Io.Read (&gSmst->SmmIo, Width, Port, 1, &Data);
44 ASSERT_EFI_ERROR (Status);
45
46 return Data;
47 }
48
49 /**
50 Writes registers in the EFI CPU I/O space.
51
52 Writes the I/O port specified by Port with registers width and value specified by Width
53 and Data respectively. Data is returned. If such operations are not supported, then ASSERT().
54 This function must guarantee that all I/O read and write operations are serialized.
55
56 @param Port The base address of the I/O operation.
57 The caller is responsible for aligning the Address if required.
58 @param Width The width of the I/O operation.
59 @param Data The value to write to the I/O port.
60
61 @return The parameter of Data.
62
63 **/
64 UINT64
65 EFIAPI
66 IoWriteWorker (
67 IN UINTN Port,
68 IN EFI_SMM_IO_WIDTH Width,
69 IN UINT64 Data
70 )
71 {
72 EFI_STATUS Status;
73
74 Status = gSmst->SmmIo.Io.Write (&gSmst->SmmIo, Width, Port, 1, &Data);
75 ASSERT_EFI_ERROR (Status);
76
77 return Data;
78 }
79
80 /**
81 Reads memory-mapped registers in the EFI system memory space.
82
83 Reads the MMIO registers specified by Address with registers width specified by Width.
84 The read value is returned. If such operations are not supported, then ASSERT().
85 This function must guarantee that all MMIO read and write operations are serialized.
86
87 @param Address The MMIO register to read.
88 The caller is responsible for aligning the Address if required.
89 @param Width The width of the I/O operation.
90
91 @return Data read from registers in the EFI system memory space.
92
93 **/
94 UINT64
95 EFIAPI
96 MmioReadWorker (
97 IN UINTN Address,
98 IN EFI_SMM_IO_WIDTH Width
99 )
100 {
101 EFI_STATUS Status;
102 UINT64 Data;
103
104 Status = gSmst->SmmIo.Mem.Read (&gSmst->SmmIo, Width, Address, 1, &Data);
105 ASSERT_EFI_ERROR (Status);
106
107 return Data;
108 }
109
110 /**
111 Writes memory-mapped registers in the EFI system memory space.
112
113 Writes the MMIO registers specified by Address with registers width and value specified by Width
114 and Data respectively. Data is returned. If such operations are not supported, then ASSERT().
115 This function must guarantee that all MMIO read and write operations are serialized.
116
117 @param Address The MMIO register to read.
118 The caller is responsible for aligning the Address if required.
119 @param Width The width of the I/O operation.
120 @param Data The value to write to the I/O port.
121
122 @return Data read from registers in the EFI system memory space.
123
124 **/
125 UINT64
126 EFIAPI
127 MmioWriteWorker (
128 IN UINTN Address,
129 IN EFI_SMM_IO_WIDTH Width,
130 IN UINT64 Data
131 )
132 {
133 EFI_STATUS Status;
134
135 Status = gSmst->SmmIo.Mem.Write (&gSmst->SmmIo, Width, Address, 1, &Data);
136 ASSERT_EFI_ERROR (Status);
137
138 return Data;
139 }
140
141 /**
142 Reads an 8-bit I/O port.
143
144 Reads the 8-bit I/O port specified by Port. The 8-bit read value is returned.
145 This function must guarantee that all I/O read and write operations are
146 serialized.
147
148 If 8-bit I/O port operations are not supported, then ASSERT().
149
150 @param Port The I/O port to read.
151
152 @return The value read.
153
154 **/
155 UINT8
156 EFIAPI
157 IoRead8 (
158 IN UINTN Port
159 )
160 {
161 return (UINT8)IoReadWorker (Port, SMM_IO_UINT8);
162 }
163
164 /**
165 Writes an 8-bit I/O port.
166
167 Writes the 8-bit I/O port specified by Port with the value specified by Value
168 and returns Value. This function must guarantee that all I/O read and write
169 operations are serialized.
170
171 If 8-bit I/O port operations are not supported, then ASSERT().
172
173 @param Port The I/O port to write.
174 @param Value The value to write to the I/O port.
175
176 @return The value written the I/O port.
177
178 **/
179 UINT8
180 EFIAPI
181 IoWrite8 (
182 IN UINTN Port,
183 IN UINT8 Value
184 )
185 {
186 return (UINT8)IoWriteWorker (Port, SMM_IO_UINT8, Value);
187 }
188
189 /**
190 Reads a 16-bit I/O port.
191
192 Reads the 16-bit I/O port specified by Port. The 16-bit read value is returned.
193 This function must guarantee that all I/O read and write operations are
194 serialized.
195
196 If Port is not aligned on a 16-bit boundary, then ASSERT().
197
198 If 16-bit I/O port operations are not supported, then ASSERT().
199
200 @param Port The I/O port to read.
201
202 @return The value read.
203
204 **/
205 UINT16
206 EFIAPI
207 IoRead16 (
208 IN UINTN Port
209 )
210 {
211 //
212 // Make sure Port is aligned on a 16-bit boundary.
213 //
214 ASSERT ((Port & 1) == 0);
215 return (UINT16)IoReadWorker (Port, SMM_IO_UINT16);
216 }
217
218 /**
219 Writes a 16-bit I/O port.
220
221 Writes the 16-bit I/O port specified by Port with the value specified by Value
222 and returns Value. This function must guarantee that all I/O read and write
223 operations are serialized.
224
225 If Port is not aligned on a 16-bit boundary, then ASSERT().
226
227 If 16-bit I/O port operations are not supported, then ASSERT().
228
229 @param Port The I/O port to write.
230 @param Value The value to write to the I/O port.
231
232 @return The value written the I/O port.
233
234 **/
235 UINT16
236 EFIAPI
237 IoWrite16 (
238 IN UINTN Port,
239 IN UINT16 Value
240 )
241 {
242 //
243 // Make sure Port is aligned on a 16-bit boundary.
244 //
245 ASSERT ((Port & 1) == 0);
246 return (UINT16)IoWriteWorker (Port, SMM_IO_UINT16, Value);
247 }
248
249 /**
250 Reads a 32-bit I/O port.
251
252 Reads the 32-bit I/O port specified by Port. The 32-bit read value is returned.
253 This function must guarantee that all I/O read and write operations are
254 serialized.
255
256 If Port is not aligned on a 32-bit boundary, then ASSERT().
257
258 If 32-bit I/O port operations are not supported, then ASSERT().
259
260 @param Port The I/O port to read.
261
262 @return The value read.
263
264 **/
265 UINT32
266 EFIAPI
267 IoRead32 (
268 IN UINTN Port
269 )
270 {
271 //
272 // Make sure Port is aligned on a 32-bit boundary.
273 //
274 ASSERT ((Port & 3) == 0);
275 return (UINT32)IoReadWorker (Port, SMM_IO_UINT32);
276 }
277
278 /**
279 Writes a 32-bit I/O port.
280
281 Writes the 32-bit I/O port specified by Port with the value specified by Value
282 and returns Value. This function must guarantee that all I/O read and write
283 operations are serialized.
284
285 If Port is not aligned on a 32-bit boundary, then ASSERT().
286
287 If 32-bit I/O port operations are not supported, then ASSERT().
288
289 @param Port The I/O port to write.
290 @param Value The value to write to the I/O port.
291
292 @return The value written the I/O port.
293
294 **/
295 UINT32
296 EFIAPI
297 IoWrite32 (
298 IN UINTN Port,
299 IN UINT32 Value
300 )
301 {
302 //
303 // Make sure Port is aligned on a 32-bit boundary.
304 //
305 ASSERT ((Port & 3) == 0);
306 return (UINT32)IoWriteWorker (Port, SMM_IO_UINT32, Value);
307 }
308
309 /**
310 Reads a 64-bit I/O port.
311
312 Reads the 64-bit I/O port specified by Port. The 64-bit read value is returned.
313 This function must guarantee that all I/O read and write operations are
314 serialized.
315
316 If Port is not aligned on a 64-bit boundary, then ASSERT().
317
318 If 64-bit I/O port operations are not supported, then ASSERT().
319
320 @param Port The I/O port to read.
321
322 @return The value read.
323
324 **/
325 UINT64
326 EFIAPI
327 IoRead64 (
328 IN UINTN Port
329 )
330 {
331 //
332 // Make sure Port is aligned on a 64-bit boundary.
333 //
334 ASSERT ((Port & 7) == 0);
335 return IoReadWorker (Port, SMM_IO_UINT64);
336 }
337
338 /**
339 Writes a 64-bit I/O port.
340
341 Writes the 64-bit I/O port specified by Port with the value specified by Value
342 and returns Value. This function must guarantee that all I/O read and write
343 operations are serialized.
344
345 If Port is not aligned on a 64-bit boundary, then ASSERT().
346
347 If 64-bit I/O port operations are not supported, then ASSERT().
348
349 @param Port The I/O port to write.
350 @param Value The value to write to the I/O port.
351
352 @return The value written the I/O port.
353
354 **/
355 UINT64
356 EFIAPI
357 IoWrite64 (
358 IN UINTN Port,
359 IN UINT64 Value
360 )
361 {
362 //
363 // Make sure Port is aligned on a 64-bit boundary.
364 //
365 ASSERT ((Port & 7) == 0);
366 return IoWriteWorker (Port, SMM_IO_UINT64, Value);
367 }
368
369 /**
370 Reads an 8-bit MMIO register.
371
372 Reads the 8-bit MMIO register specified by Address. The 8-bit read value is
373 returned. This function must guarantee that all MMIO read and write
374 operations are serialized.
375
376 If 8-bit MMIO register operations are not supported, then ASSERT().
377
378 @param Address The MMIO register to read.
379
380 @return The value read.
381
382 **/
383 UINT8
384 EFIAPI
385 MmioRead8 (
386 IN UINTN Address
387 )
388 {
389 return (UINT8)MmioReadWorker (Address, SMM_IO_UINT8);
390 }
391
392 /**
393 Writes an 8-bit MMIO register.
394
395 Writes the 8-bit MMIO register specified by Address with the value specified
396 by Value and returns Value. This function must guarantee that all MMIO read
397 and write operations are serialized.
398
399 If 8-bit MMIO register operations are not supported, then ASSERT().
400
401 @param Address The MMIO register to write.
402 @param Value The value to write to the MMIO register.
403
404 **/
405 UINT8
406 EFIAPI
407 MmioWrite8 (
408 IN UINTN Address,
409 IN UINT8 Value
410 )
411 {
412 return (UINT8)MmioWriteWorker (Address, SMM_IO_UINT8, Value);
413 }
414
415 /**
416 Reads a 16-bit MMIO register.
417
418 Reads the 16-bit MMIO register specified by Address. The 16-bit read value is
419 returned. This function must guarantee that all MMIO read and write
420 operations are serialized.
421
422 If Address is not aligned on a 16-bit boundary, then ASSERT().
423
424 If 16-bit MMIO register operations are not supported, then ASSERT().
425
426 @param Address The MMIO register to read.
427
428 @return The value read.
429
430 **/
431 UINT16
432 EFIAPI
433 MmioRead16 (
434 IN UINTN Address
435 )
436 {
437 //
438 // Make sure Address is aligned on a 16-bit boundary.
439 //
440 ASSERT ((Address & 1) == 0);
441 return (UINT16)MmioReadWorker (Address, SMM_IO_UINT16);
442 }
443
444 /**
445 Writes a 16-bit MMIO register.
446
447 Writes the 16-bit MMIO register specified by Address with the value specified
448 by Value and returns Value. This function must guarantee that all MMIO read
449 and write operations are serialized.
450
451 If Address is not aligned on a 16-bit boundary, then ASSERT().
452
453 If 16-bit MMIO register operations are not supported, then ASSERT().
454
455 @param Address The MMIO register to write.
456 @param Value The value to write to the MMIO register.
457
458 **/
459 UINT16
460 EFIAPI
461 MmioWrite16 (
462 IN UINTN Address,
463 IN UINT16 Value
464 )
465 {
466 //
467 // Make sure Address is aligned on a 16-bit boundary.
468 //
469 ASSERT ((Address & 1) == 0);
470 return (UINT16)MmioWriteWorker (Address, SMM_IO_UINT16, Value);
471 }
472
473 /**
474 Reads a 32-bit MMIO register.
475
476 Reads the 32-bit MMIO register specified by Address. The 32-bit read value is
477 returned. This function must guarantee that all MMIO read and write
478 operations are serialized.
479
480 If Address is not aligned on a 32-bit boundary, then ASSERT().
481
482 If 32-bit MMIO register operations are not supported, then ASSERT().
483
484 @param Address The MMIO register to read.
485
486 @return The value read.
487
488 **/
489 UINT32
490 EFIAPI
491 MmioRead32 (
492 IN UINTN Address
493 )
494 {
495 //
496 // Make sure Address is aligned on a 32-bit boundary.
497 //
498 ASSERT ((Address & 3) == 0);
499 return (UINT32)MmioReadWorker (Address, SMM_IO_UINT32);
500 }
501
502 /**
503 Writes a 32-bit MMIO register.
504
505 Writes the 32-bit MMIO register specified by Address with the value specified
506 by Value and returns Value. This function must guarantee that all MMIO read
507 and write operations are serialized.
508
509 If Address is not aligned on a 32-bit boundary, then ASSERT().
510
511 If 32-bit MMIO register operations are not supported, then ASSERT().
512
513 @param Address The MMIO register to write.
514 @param Value The value to write to the MMIO register.
515
516 **/
517 UINT32
518 EFIAPI
519 MmioWrite32 (
520 IN UINTN Address,
521 IN UINT32 Value
522 )
523 {
524 //
525 // Make sure Address is aligned on a 32-bit boundary.
526 //
527 ASSERT ((Address & 3) == 0);
528 return (UINT32)MmioWriteWorker (Address, SMM_IO_UINT32, Value);
529 }
530
531 /**
532 Reads a 64-bit MMIO register.
533
534 Reads the 64-bit MMIO register specified by Address. The 64-bit read value is
535 returned. This function must guarantee that all MMIO read and write
536 operations are serialized.
537
538 If Address is not aligned on a 64-bit boundary, then ASSERT().
539
540 If 64-bit MMIO register operations are not supported, then ASSERT().
541
542 @param Address The MMIO register to read.
543
544 @return The value read.
545
546 **/
547 UINT64
548 EFIAPI
549 MmioRead64 (
550 IN UINTN Address
551 )
552 {
553 //
554 // Make sure Address is aligned on a 64-bit boundary.
555 //
556 ASSERT ((Address & 7) == 0);
557 return (UINT64)MmioReadWorker (Address, SMM_IO_UINT64);
558 }
559
560 /**
561 Writes a 64-bit MMIO register.
562
563 Writes the 64-bit MMIO register specified by Address with the value specified
564 by Value and returns Value. This function must guarantee that all MMIO read
565 and write operations are serialized.
566
567 If Address is not aligned on a 64-bit boundary, then ASSERT().
568
569 If 64-bit MMIO register operations are not supported, then ASSERT().
570
571 @param Address The MMIO register to write.
572 @param Value The value to write to the MMIO register.
573
574 **/
575 UINT64
576 EFIAPI
577 MmioWrite64 (
578 IN UINTN Address,
579 IN UINT64 Value
580 )
581 {
582 //
583 // Make sure Address is aligned on a 64-bit boundary.
584 //
585 ASSERT ((Address & 7) == 0);
586 return (UINT64)MmioWriteWorker (Address, SMM_IO_UINT64, Value);
587 }