clean up modules
[mirror_edk2.git] / IntelFrameworkPkg / Library / DxeIoLibCpuIo / IoHighLevel.c
CommitLineData
79964ac8 1/** @file\r
2 High-level Io/Mmio functions.\r
3\r
4 All assertions for bit field operations are handled bit field functions in the\r
5 Base Library.\r
6\r
7 Copyright (c) 2006, Intel Corporation<BR>\r
8 All rights reserved. This program and the accompanying materials\r
9 are licensed and made available under the terms and conditions of the BSD License\r
10 which accompanies this distribution. The full text of the license may be found at\r
11 http://opensource.org/licenses/bsd-license.php\r
12\r
13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
14 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
15\r
16 Module Name: IoHighLevel.c\r
17\r
18 The following IoLib instances share the same version of this file:\r
19\r
20 BaseIoLibIntrinsic\r
21 DxeIoLibCpuIo\r
22 PeiIoLibCpuIo\r
23\r
24**/\r
25\r
26#include "DxeCpuIoLibInternal.h"\r
27\r
28/**\r
29 Reads an 8-bit I/O port, performs a bitwise inclusive OR, and writes the\r
30 result back to the 8-bit I/O port.\r
31\r
32 Reads the 8-bit I/O port specified by Port, performs a bitwise inclusive OR\r
33 between the read result and the value specified by OrData, and writes the\r
34 result to the 8-bit I/O port specified by Port. The value written to the I/O\r
35 port is returned. This function must guarantee that all I/O read and write\r
36 operations are serialized.\r
37\r
38 If 8-bit I/O port operations are not supported, then ASSERT().\r
39\r
40 @param Port The I/O port to write.\r
41 @param OrData The value to OR with the read value from the I/O port.\r
42\r
43 @return The value written back to the I/O port.\r
44\r
45**/\r
46UINT8\r
47EFIAPI\r
48IoOr8 (\r
49 IN UINTN Port,\r
50 IN UINT8 OrData\r
51 )\r
52{\r
53 return IoWrite8 (Port, (UINT8) (IoRead8 (Port) | OrData));\r
54}\r
55\r
56/**\r
57 Reads an 8-bit I/O port, performs a bitwise AND, and writes the result back\r
58 to the 8-bit I/O port.\r
59\r
60 Reads the 8-bit I/O port specified by Port, performs a bitwise AND between\r
61 the read result and the value specified by AndData, and writes the result to\r
62 the 8-bit I/O port specified by Port. The value written to the I/O port is\r
63 returned. This function must guarantee that all I/O read and write operations\r
64 are serialized.\r
65\r
66 If 8-bit I/O port operations are not supported, then ASSERT().\r
67\r
68 @param Port The I/O port to write.\r
69 @param AndData The value to AND with the read value from the I/O port.\r
70\r
71 @return The value written back to the I/O port.\r
72\r
73**/\r
74UINT8\r
75EFIAPI\r
76IoAnd8 (\r
77 IN UINTN Port,\r
78 IN UINT8 AndData\r
79 )\r
80{\r
81 return IoWrite8 (Port, (UINT8) (IoRead8 (Port) & AndData));\r
82}\r
83\r
84/**\r
85 Reads an 8-bit I/O port, performs a bitwise AND followed by a bitwise\r
86 inclusive OR, and writes the result back to the 8-bit I/O port.\r
87\r
88 Reads the 8-bit I/O port specified by Port, performs a bitwise AND between\r
89 the read result and the value specified by AndData, performs a bitwise OR\r
90 between the result of the AND operation and the value specified by OrData,\r
91 and writes the result to the 8-bit I/O port specified by Port. The value\r
92 written to the I/O port is returned. This function must guarantee that all\r
93 I/O read and write operations are serialized.\r
94\r
95 If 8-bit I/O port operations are not supported, then ASSERT().\r
96\r
97 @param Port The I/O port to write.\r
98 @param AndData The value to AND with the read value from the I/O port.\r
99 @param OrData The value to OR with the result of the AND operation.\r
100\r
101 @return The value written back to the I/O port.\r
102\r
103**/\r
104UINT8\r
105EFIAPI\r
106IoAndThenOr8 (\r
107 IN UINTN Port,\r
108 IN UINT8 AndData,\r
109 IN UINT8 OrData\r
110 )\r
111{\r
112 return IoWrite8 (Port, (UINT8) ((IoRead8 (Port) & AndData) | OrData));\r
113}\r
114\r
115/**\r
116 Reads a bit field of an I/O register.\r
117\r
118 Reads the bit field in an 8-bit I/O register. The bit field is specified by\r
119 the StartBit and the EndBit. The value of the bit field is returned.\r
120\r
121 If 8-bit I/O port operations are not supported, then ASSERT().\r
122 If StartBit is greater than 7, then ASSERT().\r
123 If EndBit is greater than 7, then ASSERT().\r
124 If EndBit is less than StartBit, then ASSERT().\r
125\r
126 @param Port The I/O port to read.\r
127 @param StartBit The ordinal of the least significant bit in the bit field.\r
128 Range 0..7.\r
129 @param EndBit The ordinal of the most significant bit in the bit field.\r
130 Range 0..7.\r
131\r
132 @return The value read.\r
133\r
134**/\r
135UINT8\r
136EFIAPI\r
137IoBitFieldRead8 (\r
138 IN UINTN Port,\r
139 IN UINTN StartBit,\r
140 IN UINTN EndBit\r
141 )\r
142{\r
143 return BitFieldRead8 (IoRead8 (Port), StartBit, EndBit);\r
144}\r
145\r
146/**\r
147 Writes a bit field to an I/O register.\r
148\r
149 Writes Value to the bit field of the I/O register. The bit field is specified\r
150 by the StartBit and the EndBit. All other bits in the destination I/O\r
151 register are preserved. The value written to the I/O port is returned. Extra\r
152 left bits in Value are stripped.\r
153\r
154 If 8-bit I/O port operations are not supported, then ASSERT().\r
155 If StartBit is greater than 7, then ASSERT().\r
156 If EndBit is greater than 7, then ASSERT().\r
157 If EndBit is less than StartBit, then ASSERT().\r
158\r
159 @param Port The I/O port to write.\r
160 @param StartBit The ordinal of the least significant bit in the bit field.\r
161 Range 0..7.\r
162 @param EndBit The ordinal of the most significant bit in the bit field.\r
163 Range 0..7.\r
164 @param Value New value of the bit field.\r
165\r
166 @return The value written back to the I/O port.\r
167\r
168**/\r
169UINT8\r
170EFIAPI\r
171IoBitFieldWrite8 (\r
172 IN UINTN Port,\r
173 IN UINTN StartBit,\r
174 IN UINTN EndBit,\r
175 IN UINT8 Value\r
176 )\r
177{\r
178 return IoWrite8 (\r
179 Port,\r
180 BitFieldWrite8 (IoRead8 (Port), StartBit, EndBit, Value)\r
181 );\r
182}\r
183\r
184/**\r
185 Reads a bit field in an 8-bit port, performs a bitwise OR, and writes the\r
186 result back to the bit field in the 8-bit port.\r
187\r
188 Reads the 8-bit I/O port specified by Port, performs a bitwise inclusive OR\r
189 between the read result and the value specified by OrData, and writes the\r
190 result to the 8-bit I/O port specified by Port. The value written to the I/O\r
191 port is returned. This function must guarantee that all I/O read and write\r
192 operations are serialized. Extra left bits in OrData are stripped.\r
193\r
194 If 8-bit I/O port operations are not supported, then ASSERT().\r
195 If StartBit is greater than 7, then ASSERT().\r
196 If EndBit is greater than 7, then ASSERT().\r
197 If EndBit is less than StartBit, then ASSERT().\r
198\r
199 @param Port The I/O port to write.\r
200 @param StartBit The ordinal of the least significant bit in the bit field.\r
201 Range 0..7.\r
202 @param EndBit The ordinal of the most significant bit in the bit field.\r
203 Range 0..7.\r
204 @param OrData The value to OR with the read value from the I/O port.\r
205\r
206 @return The value written back to the I/O port.\r
207\r
208**/\r
209UINT8\r
210EFIAPI\r
211IoBitFieldOr8 (\r
212 IN UINTN Port,\r
213 IN UINTN StartBit,\r
214 IN UINTN EndBit,\r
215 IN UINT8 OrData\r
216 )\r
217{\r
218 return IoWrite8 (\r
219 Port,\r
220 BitFieldOr8 (IoRead8 (Port), StartBit, EndBit, OrData)\r
221 );\r
222}\r
223\r
224/**\r
225 Reads a bit field in an 8-bit port, performs a bitwise AND, and writes the\r
226 result back to the bit field in the 8-bit port.\r
227\r
228 Reads the 8-bit I/O port specified by Port, performs a bitwise AND between\r
229 the read result and the value specified by AndData, and writes the result to\r
230 the 8-bit I/O port specified by Port. The value written to the I/O port is\r
231 returned. This function must guarantee that all I/O read and write operations\r
232 are serialized. Extra left bits in AndData are stripped.\r
233\r
234 If 8-bit I/O port operations are not supported, then ASSERT().\r
235 If StartBit is greater than 7, then ASSERT().\r
236 If EndBit is greater than 7, then ASSERT().\r
237 If EndBit is less than StartBit, then ASSERT().\r
238\r
239 @param Port The I/O port to write.\r
240 @param StartBit The ordinal of the least significant bit in the bit field.\r
241 Range 0..7.\r
242 @param EndBit The ordinal of the most significant bit in the bit field.\r
243 Range 0..7.\r
244 @param AndData The value to AND with the read value from the I/O port.\r
245\r
246 @return The value written back to the I/O port.\r
247\r
248**/\r
249UINT8\r
250EFIAPI\r
251IoBitFieldAnd8 (\r
252 IN UINTN Port,\r
253 IN UINTN StartBit,\r
254 IN UINTN EndBit,\r
255 IN UINT8 AndData\r
256 )\r
257{\r
258 return IoWrite8 (\r
259 Port,\r
260 BitFieldAnd8 (IoRead8 (Port), StartBit, EndBit, AndData)\r
261 );\r
262}\r
263\r
264/**\r
265 Reads a bit field in an 8-bit port, performs a bitwise AND followed by a\r
266 bitwise inclusive OR, and writes the result back to the bit field in the\r
267 8-bit port.\r
268\r
269 Reads the 8-bit I/O port specified by Port, performs a bitwise AND followed\r
270 by a bitwise inclusive OR between the read result and the value specified by\r
271 AndData, and writes the result to the 8-bit I/O port specified by Port. The\r
272 value written to the I/O port is returned. This function must guarantee that\r
273 all I/O read and write operations are serialized. Extra left bits in both\r
274 AndData and OrData are stripped.\r
275\r
276 If 8-bit I/O port operations are not supported, then ASSERT().\r
277 If StartBit is greater than 7, then ASSERT().\r
278 If EndBit is greater than 7, then ASSERT().\r
279 If EndBit is less than StartBit, then ASSERT().\r
280\r
281 @param Port The I/O port to write.\r
282 @param StartBit The ordinal of the least significant bit in the bit field.\r
283 Range 0..7.\r
284 @param EndBit The ordinal of the most significant bit in the bit field.\r
285 Range 0..7.\r
286 @param AndData The value to AND with the read value from the I/O port.\r
287 @param OrData The value to OR with the result of the AND operation.\r
288\r
289 @return The value written back to the I/O port.\r
290\r
291**/\r
292UINT8\r
293EFIAPI\r
294IoBitFieldAndThenOr8 (\r
295 IN UINTN Port,\r
296 IN UINTN StartBit,\r
297 IN UINTN EndBit,\r
298 IN UINT8 AndData,\r
299 IN UINT8 OrData\r
300 )\r
301{\r
302 return IoWrite8 (\r
303 Port,\r
304 BitFieldAndThenOr8 (IoRead8 (Port), StartBit, EndBit, AndData, OrData)\r
305 );\r
306}\r
307\r
308/**\r
309 Reads a 16-bit I/O port, performs a bitwise inclusive OR, and writes the\r
310 result back to the 16-bit I/O port.\r
311\r
312 Reads the 16-bit I/O port specified by Port, performs a bitwise inclusive OR\r
313 between the read result and the value specified by OrData, and writes the\r
314 result to the 16-bit I/O port specified by Port. The value written to the I/O\r
315 port is returned. This function must guarantee that all I/O read and write\r
316 operations are serialized.\r
317\r
318 If 16-bit I/O port operations are not supported, then ASSERT().\r
319\r
320 @param Port The I/O port to write.\r
321 @param OrData The value to OR with the read value from the I/O port.\r
322\r
323 @return The value written back to the I/O port.\r
324\r
325**/\r
326UINT16\r
327EFIAPI\r
328IoOr16 (\r
329 IN UINTN Port,\r
330 IN UINT16 OrData\r
331 )\r
332{\r
333 return IoWrite16 (Port, (UINT16) (IoRead16 (Port) | OrData));\r
334}\r
335\r
336/**\r
337 Reads a 16-bit I/O port, performs a bitwise AND, and writes the result back\r
338 to the 16-bit I/O port.\r
339\r
340 Reads the 16-bit I/O port specified by Port, performs a bitwise AND between\r
341 the read result and the value specified by AndData, and writes the result to\r
342 the 16-bit I/O port specified by Port. The value written to the I/O port is\r
343 returned. This function must guarantee that all I/O read and write operations\r
344 are serialized.\r
345\r
346 If 16-bit I/O port operations are not supported, then ASSERT().\r
347\r
348 @param Port The I/O port to write.\r
349 @param AndData The value to AND with the read value from the I/O port.\r
350\r
351 @return The value written back to the I/O port.\r
352\r
353**/\r
354UINT16\r
355EFIAPI\r
356IoAnd16 (\r
357 IN UINTN Port,\r
358 IN UINT16 AndData\r
359 )\r
360{\r
361 return IoWrite16 (Port, (UINT16) (IoRead16 (Port) & AndData));\r
362}\r
363\r
364/**\r
365 Reads a 16-bit I/O port, performs a bitwise AND followed by a bitwise\r
366 inclusive OR, and writes the result back to the 16-bit I/O port.\r
367\r
368 Reads the 16-bit I/O port specified by Port, performs a bitwise AND between\r
369 the read result and the value specified by AndData, performs a bitwise OR\r
370 between the result of the AND operation and the value specified by OrData,\r
371 and writes the result to the 16-bit I/O port specified by Port. The value\r
372 written to the I/O port is returned. This function must guarantee that all\r
373 I/O read and write operations are serialized.\r
374\r
375 If 16-bit I/O port operations are not supported, then ASSERT().\r
376\r
377 @param Port The I/O port to write.\r
378 @param AndData The value to AND with the read value from the I/O port.\r
379 @param OrData The value to OR with the result of the AND operation.\r
380\r
381 @return The value written back to the I/O port.\r
382\r
383**/\r
384UINT16\r
385EFIAPI\r
386IoAndThenOr16 (\r
387 IN UINTN Port,\r
388 IN UINT16 AndData,\r
389 IN UINT16 OrData\r
390 )\r
391{\r
392 return IoWrite16 (Port, (UINT16) ((IoRead16 (Port) & AndData) | OrData));\r
393}\r
394\r
395/**\r
396 Reads a bit field of an I/O register.\r
397\r
398 Reads the bit field in a 16-bit I/O register. The bit field is specified by\r
399 the StartBit and the EndBit. The value of the bit field is returned.\r
400\r
401 If 16-bit I/O port operations are not supported, then ASSERT().\r
402 If StartBit is greater than 15, then ASSERT().\r
403 If EndBit is greater than 15, then ASSERT().\r
404 If EndBit is less than StartBit, then ASSERT().\r
405\r
406 @param Port The I/O port to read.\r
407 @param StartBit The ordinal of the least significant bit in the bit field.\r
408 Range 0..15.\r
409 @param EndBit The ordinal of the most significant bit in the bit field.\r
410 Range 0..15.\r
411\r
412 @return The value read.\r
413\r
414**/\r
415UINT16\r
416EFIAPI\r
417IoBitFieldRead16 (\r
418 IN UINTN Port,\r
419 IN UINTN StartBit,\r
420 IN UINTN EndBit\r
421 )\r
422{\r
423 return BitFieldRead16 (IoRead16 (Port), StartBit, EndBit);\r
424}\r
425\r
426/**\r
427 Writes a bit field to an I/O register.\r
428\r
429 Writes Value to the bit field of the I/O register. The bit field is specified\r
430 by the StartBit and the EndBit. All other bits in the destination I/O\r
431 register are preserved. The value written to the I/O port is returned. Extra\r
432 left bits in Value are stripped.\r
433\r
434 If 16-bit I/O port operations are not supported, then ASSERT().\r
435 If StartBit is greater than 15, then ASSERT().\r
436 If EndBit is greater than 15, then ASSERT().\r
437 If EndBit is less than StartBit, then ASSERT().\r
438\r
439 @param Port The I/O port to write.\r
440 @param StartBit The ordinal of the least significant bit in the bit field.\r
441 Range 0..15.\r
442 @param EndBit The ordinal of the most significant bit in the bit field.\r
443 Range 0..15.\r
444 @param Value New value of the bit field.\r
445\r
446 @return The value written back to the I/O port.\r
447\r
448**/\r
449UINT16\r
450EFIAPI\r
451IoBitFieldWrite16 (\r
452 IN UINTN Port,\r
453 IN UINTN StartBit,\r
454 IN UINTN EndBit,\r
455 IN UINT16 Value\r
456 )\r
457{\r
458 return IoWrite16 (\r
459 Port,\r
460 BitFieldWrite16 (IoRead16 (Port), StartBit, EndBit, Value)\r
461 );\r
462}\r
463\r
464/**\r
465 Reads a bit field in a 16-bit port, performs a bitwise OR, and writes the\r
466 result back to the bit field in the 16-bit port.\r
467\r
468 Reads the 16-bit I/O port specified by Port, performs a bitwise inclusive OR\r
469 between the read result and the value specified by OrData, and writes the\r
470 result to the 16-bit I/O port specified by Port. The value written to the I/O\r
471 port is returned. This function must guarantee that all I/O read and write\r
472 operations are serialized. Extra left bits in OrData are stripped.\r
473\r
474 If 16-bit I/O port operations are not supported, then ASSERT().\r
475 If StartBit is greater than 15, then ASSERT().\r
476 If EndBit is greater than 15, then ASSERT().\r
477 If EndBit is less than StartBit, then ASSERT().\r
478\r
479 @param Port The I/O port to write.\r
480 @param StartBit The ordinal of the least significant bit in the bit field.\r
481 Range 0..15.\r
482 @param EndBit The ordinal of the most significant bit in the bit field.\r
483 Range 0..15.\r
484 @param OrData The value to OR with the read value from the I/O port.\r
485\r
486 @return The value written back to the I/O port.\r
487\r
488**/\r
489UINT16\r
490EFIAPI\r
491IoBitFieldOr16 (\r
492 IN UINTN Port,\r
493 IN UINTN StartBit,\r
494 IN UINTN EndBit,\r
495 IN UINT16 OrData\r
496 )\r
497{\r
498 return IoWrite16 (\r
499 Port,\r
500 BitFieldOr16 (IoRead16 (Port), StartBit, EndBit, OrData)\r
501 );\r
502}\r
503\r
504/**\r
505 Reads a bit field in a 16-bit port, performs a bitwise AND, and writes the\r
506 result back to the bit field in the 16-bit port.\r
507\r
508 Reads the 16-bit I/O port specified by Port, performs a bitwise AND between\r
509 the read result and the value specified by AndData, and writes the result to\r
510 the 16-bit I/O port specified by Port. The value written to the I/O port is\r
511 returned. This function must guarantee that all I/O read and write operations\r
512 are serialized. Extra left bits in AndData are stripped.\r
513\r
514 If 16-bit I/O port operations are not supported, then ASSERT().\r
515 If StartBit is greater than 15, then ASSERT().\r
516 If EndBit is greater than 15, then ASSERT().\r
517 If EndBit is less than StartBit, then ASSERT().\r
518\r
519 @param Port The I/O port to write.\r
520 @param StartBit The ordinal of the least significant bit in the bit field.\r
521 Range 0..15.\r
522 @param EndBit The ordinal of the most significant bit in the bit field.\r
523 Range 0..15.\r
524 @param AndData The value to AND with the read value from the I/O port.\r
525\r
526 @return The value written back to the I/O port.\r
527\r
528**/\r
529UINT16\r
530EFIAPI\r
531IoBitFieldAnd16 (\r
532 IN UINTN Port,\r
533 IN UINTN StartBit,\r
534 IN UINTN EndBit,\r
535 IN UINT16 AndData\r
536 )\r
537{\r
538 return IoWrite16 (\r
539 Port,\r
540 BitFieldAnd16 (IoRead16 (Port), StartBit, EndBit, AndData)\r
541 );\r
542}\r
543\r
544/**\r
545 Reads a bit field in a 16-bit port, performs a bitwise AND followed by a\r
546 bitwise inclusive OR, and writes the result back to the bit field in the\r
547 16-bit port.\r
548\r
549 Reads the 16-bit I/O port specified by Port, performs a bitwise AND followed\r
550 by a bitwise inclusive OR between the read result and the value specified by\r
551 AndData, and writes the result to the 16-bit I/O port specified by Port. The\r
552 value written to the I/O port is returned. This function must guarantee that\r
553 all I/O read and write operations are serialized. Extra left bits in both\r
554 AndData and OrData are stripped.\r
555\r
556 If 16-bit I/O port operations are not supported, then ASSERT().\r
557 If StartBit is greater than 15, then ASSERT().\r
558 If EndBit is greater than 15, then ASSERT().\r
559 If EndBit is less than StartBit, then ASSERT().\r
560\r
561 @param Port The I/O port to write.\r
562 @param StartBit The ordinal of the least significant bit in the bit field.\r
563 Range 0..15.\r
564 @param EndBit The ordinal of the most significant bit in the bit field.\r
565 Range 0..15.\r
566 @param AndData The value to AND with the read value from the I/O port.\r
567 @param OrData The value to OR with the result of the AND operation.\r
568\r
569 @return The value written back to the I/O port.\r
570\r
571**/\r
572UINT16\r
573EFIAPI\r
574IoBitFieldAndThenOr16 (\r
575 IN UINTN Port,\r
576 IN UINTN StartBit,\r
577 IN UINTN EndBit,\r
578 IN UINT16 AndData,\r
579 IN UINT16 OrData\r
580 )\r
581{\r
582 return IoWrite16 (\r
583 Port,\r
584 BitFieldAndThenOr16 (IoRead16 (Port), StartBit, EndBit, AndData, OrData)\r
585 );\r
586}\r
587\r
588/**\r
589 Reads a 32-bit I/O port, performs a bitwise inclusive OR, and writes the\r
590 result back to the 32-bit I/O port.\r
591\r
592 Reads the 32-bit I/O port specified by Port, performs a bitwise inclusive OR\r
593 between the read result and the value specified by OrData, and writes the\r
594 result to the 32-bit I/O port specified by Port. The value written to the I/O\r
595 port is returned. This function must guarantee that all I/O read and write\r
596 operations are serialized.\r
597\r
598 If 32-bit I/O port operations are not supported, then ASSERT().\r
599\r
600 @param Port The I/O port to write.\r
601 @param OrData The value to OR with the read value from the I/O port.\r
602\r
603 @return The value written back to the I/O port.\r
604\r
605**/\r
606UINT32\r
607EFIAPI\r
608IoOr32 (\r
609 IN UINTN Port,\r
610 IN UINT32 OrData\r
611 )\r
612{\r
613 return IoWrite32 (Port, IoRead32 (Port) | OrData);\r
614}\r
615\r
616/**\r
617 Reads a 32-bit I/O port, performs a bitwise AND, and writes the result back\r
618 to the 32-bit I/O port.\r
619\r
620 Reads the 32-bit I/O port specified by Port, performs a bitwise AND between\r
621 the read result and the value specified by AndData, and writes the result to\r
622 the 32-bit I/O port specified by Port. The value written to the I/O port is\r
623 returned. This function must guarantee that all I/O read and write operations\r
624 are serialized.\r
625\r
626 If 32-bit I/O port operations are not supported, then ASSERT().\r
627\r
628 @param Port The I/O port to write.\r
629 @param AndData The value to AND with the read value from the I/O port.\r
630\r
631 @return The value written back to the I/O port.\r
632\r
633**/\r
634UINT32\r
635EFIAPI\r
636IoAnd32 (\r
637 IN UINTN Port,\r
638 IN UINT32 AndData\r
639 )\r
640{\r
641 return IoWrite32 (Port, IoRead32 (Port) & AndData);\r
642}\r
643\r
644/**\r
645 Reads a 32-bit I/O port, performs a bitwise AND followed by a bitwise\r
646 inclusive OR, and writes the result back to the 32-bit I/O port.\r
647\r
648 Reads the 32-bit I/O port specified by Port, performs a bitwise AND between\r
649 the read result and the value specified by AndData, performs a bitwise OR\r
650 between the result of the AND operation and the value specified by OrData,\r
651 and writes the result to the 32-bit I/O port specified by Port. The value\r
652 written to the I/O port is returned. This function must guarantee that all\r
653 I/O read and write operations are serialized.\r
654\r
655 If 32-bit I/O port operations are not supported, then ASSERT().\r
656\r
657 @param Port The I/O port to write.\r
658 @param AndData The value to AND with the read value from the I/O port.\r
659 @param OrData The value to OR with the result of the AND operation.\r
660\r
661 @return The value written back to the I/O port.\r
662\r
663**/\r
664UINT32\r
665EFIAPI\r
666IoAndThenOr32 (\r
667 IN UINTN Port,\r
668 IN UINT32 AndData,\r
669 IN UINT32 OrData\r
670 )\r
671{\r
672 return IoWrite32 (Port, (IoRead32 (Port) & AndData) | OrData);\r
673}\r
674\r
675/**\r
676 Reads a bit field of an I/O register.\r
677\r
678 Reads the bit field in a 32-bit I/O register. The bit field is specified by\r
679 the StartBit and the EndBit. The value of the bit field is returned.\r
680\r
681 If 32-bit I/O port operations are not supported, then ASSERT().\r
682 If StartBit is greater than 31, then ASSERT().\r
683 If EndBit is greater than 31, then ASSERT().\r
684 If EndBit is less than StartBit, then ASSERT().\r
685\r
686 @param Port The I/O port to read.\r
687 @param StartBit The ordinal of the least significant bit in the bit field.\r
688 Range 0..31.\r
689 @param EndBit The ordinal of the most significant bit in the bit field.\r
690 Range 0..31.\r
691\r
692 @return The value read.\r
693\r
694**/\r
695UINT32\r
696EFIAPI\r
697IoBitFieldRead32 (\r
698 IN UINTN Port,\r
699 IN UINTN StartBit,\r
700 IN UINTN EndBit\r
701 )\r
702{\r
703 return BitFieldRead32 (IoRead32 (Port), StartBit, EndBit);\r
704}\r
705\r
706/**\r
707 Writes a bit field to an I/O register.\r
708\r
709 Writes Value to the bit field of the I/O register. The bit field is specified\r
710 by the StartBit and the EndBit. All other bits in the destination I/O\r
711 register are preserved. The value written to the I/O port is returned. Extra\r
712 left bits in Value are stripped.\r
713\r
714 If 32-bit I/O port operations are not supported, then ASSERT().\r
715 If StartBit is greater than 31, then ASSERT().\r
716 If EndBit is greater than 31, then ASSERT().\r
717 If EndBit is less than StartBit, then ASSERT().\r
718\r
719 @param Port The I/O port to write.\r
720 @param StartBit The ordinal of the least significant bit in the bit field.\r
721 Range 0..31.\r
722 @param EndBit The ordinal of the most significant bit in the bit field.\r
723 Range 0..31.\r
724 @param Value New value of the bit field.\r
725\r
726 @return The value written back to the I/O port.\r
727\r
728**/\r
729UINT32\r
730EFIAPI\r
731IoBitFieldWrite32 (\r
732 IN UINTN Port,\r
733 IN UINTN StartBit,\r
734 IN UINTN EndBit,\r
735 IN UINT32 Value\r
736 )\r
737{\r
738 return IoWrite32 (\r
739 Port,\r
740 BitFieldWrite32 (IoRead32 (Port), StartBit, EndBit, Value)\r
741 );\r
742}\r
743\r
744/**\r
745 Reads a bit field in a 32-bit port, performs a bitwise OR, and writes the\r
746 result back to the bit field in the 32-bit port.\r
747\r
748 Reads the 32-bit I/O port specified by Port, performs a bitwise inclusive OR\r
749 between the read result and the value specified by OrData, and writes the\r
750 result to the 32-bit I/O port specified by Port. The value written to the I/O\r
751 port is returned. This function must guarantee that all I/O read and write\r
752 operations are serialized. Extra left bits in OrData are stripped.\r
753\r
754 If 32-bit I/O port operations are not supported, then ASSERT().\r
755 If StartBit is greater than 31, then ASSERT().\r
756 If EndBit is greater than 31, then ASSERT().\r
757 If EndBit is less than StartBit, then ASSERT().\r
758\r
759 @param Port The I/O port to write.\r
760 @param StartBit The ordinal of the least significant bit in the bit field.\r
761 Range 0..31.\r
762 @param EndBit The ordinal of the most significant bit in the bit field.\r
763 Range 0..31.\r
764 @param OrData The value to OR with the read value from the I/O port.\r
765\r
766 @return The value written back to the I/O port.\r
767\r
768**/\r
769UINT32\r
770EFIAPI\r
771IoBitFieldOr32 (\r
772 IN UINTN Port,\r
773 IN UINTN StartBit,\r
774 IN UINTN EndBit,\r
775 IN UINT32 OrData\r
776 )\r
777{\r
778 return IoWrite32 (\r
779 Port,\r
780 BitFieldOr32 (IoRead32 (Port), StartBit, EndBit, OrData)\r
781 );\r
782}\r
783\r
784/**\r
785 Reads a bit field in a 32-bit port, performs a bitwise AND, and writes the\r
786 result back to the bit field in the 32-bit port.\r
787\r
788 Reads the 32-bit I/O port specified by Port, performs a bitwise AND between\r
789 the read result and the value specified by AndData, and writes the result to\r
790 the 32-bit I/O port specified by Port. The value written to the I/O port is\r
791 returned. This function must guarantee that all I/O read and write operations\r
792 are serialized. Extra left bits in AndData are stripped.\r
793\r
794 If 32-bit I/O port operations are not supported, then ASSERT().\r
795 If StartBit is greater than 31, then ASSERT().\r
796 If EndBit is greater than 31, then ASSERT().\r
797 If EndBit is less than StartBit, then ASSERT().\r
798\r
799 @param Port The I/O port to write.\r
800 @param StartBit The ordinal of the least significant bit in the bit field.\r
801 Range 0..31.\r
802 @param EndBit The ordinal of the most significant bit in the bit field.\r
803 Range 0..31.\r
804 @param AndData The value to AND with the read value from the I/O port.\r
805\r
806 @return The value written back to the I/O port.\r
807\r
808**/\r
809UINT32\r
810EFIAPI\r
811IoBitFieldAnd32 (\r
812 IN UINTN Port,\r
813 IN UINTN StartBit,\r
814 IN UINTN EndBit,\r
815 IN UINT32 AndData\r
816 )\r
817{\r
818 return IoWrite32 (\r
819 Port,\r
820 BitFieldAnd32 (IoRead32 (Port), StartBit, EndBit, AndData)\r
821 );\r
822}\r
823\r
824/**\r
825 Reads a bit field in a 32-bit port, performs a bitwise AND followed by a\r
826 bitwise inclusive OR, and writes the result back to the bit field in the\r
827 32-bit port.\r
828\r
829 Reads the 32-bit I/O port specified by Port, performs a bitwise AND followed\r
830 by a bitwise inclusive OR between the read result and the value specified by\r
831 AndData, and writes the result to the 32-bit I/O port specified by Port. The\r
832 value written to the I/O port is returned. This function must guarantee that\r
833 all I/O read and write operations are serialized. Extra left bits in both\r
834 AndData and OrData are stripped.\r
835\r
836 If 32-bit I/O port operations are not supported, then ASSERT().\r
837 If StartBit is greater than 31, then ASSERT().\r
838 If EndBit is greater than 31, then ASSERT().\r
839 If EndBit is less than StartBit, then ASSERT().\r
840\r
841 @param Port The I/O port to write.\r
842 @param StartBit The ordinal of the least significant bit in the bit field.\r
843 Range 0..31.\r
844 @param EndBit The ordinal of the most significant bit in the bit field.\r
845 Range 0..31.\r
846 @param AndData The value to AND with the read value from the I/O port.\r
847 @param OrData The value to OR with the result of the AND operation.\r
848\r
849 @return The value written back to the I/O port.\r
850\r
851**/\r
852UINT32\r
853EFIAPI\r
854IoBitFieldAndThenOr32 (\r
855 IN UINTN Port,\r
856 IN UINTN StartBit,\r
857 IN UINTN EndBit,\r
858 IN UINT32 AndData,\r
859 IN UINT32 OrData\r
860 )\r
861{\r
862 return IoWrite32 (\r
863 Port,\r
864 BitFieldAndThenOr32 (IoRead32 (Port), StartBit, EndBit, AndData, OrData)\r
865 );\r
866}\r
867\r
868/**\r
869 Reads a 64-bit I/O port, performs a bitwise inclusive OR, and writes the\r
870 result back to the 64-bit I/O port.\r
871\r
872 Reads the 64-bit I/O port specified by Port, performs a bitwise inclusive OR\r
873 between the read result and the value specified by OrData, and writes the\r
874 result to the 64-bit I/O port specified by Port. The value written to the I/O\r
875 port is returned. This function must guarantee that all I/O read and write\r
876 operations are serialized.\r
877\r
878 If 64-bit I/O port operations are not supported, then ASSERT().\r
879\r
880 @param Port The I/O port to write.\r
881 @param OrData The value to OR with the read value from the I/O port.\r
882\r
883 @return The value written back to the I/O port.\r
884\r
885**/\r
886UINT64\r
887EFIAPI\r
888IoOr64 (\r
889 IN UINTN Port,\r
890 IN UINT64 OrData\r
891 )\r
892{\r
893 return IoWrite64 (Port, IoRead64 (Port) | OrData);\r
894}\r
895\r
896/**\r
897 Reads a 64-bit I/O port, performs a bitwise AND, and writes the result back\r
898 to the 64-bit I/O port.\r
899\r
900 Reads the 64-bit I/O port specified by Port, performs a bitwise AND between\r
901 the read result and the value specified by AndData, and writes the result to\r
902 the 64-bit I/O port specified by Port. The value written to the I/O port is\r
903 returned. This function must guarantee that all I/O read and write operations\r
904 are serialized.\r
905\r
906 If 64-bit I/O port operations are not supported, then ASSERT().\r
907\r
908 @param Port The I/O port to write.\r
909 @param AndData The value to AND with the read value from the I/O port.\r
910\r
911 @return The value written back to the I/O port.\r
912\r
913**/\r
914UINT64\r
915EFIAPI\r
916IoAnd64 (\r
917 IN UINTN Port,\r
918 IN UINT64 AndData\r
919 )\r
920{\r
921 return IoWrite64 (Port, IoRead64 (Port) & AndData);\r
922}\r
923\r
924/**\r
925 Reads a 64-bit I/O port, performs a bitwise AND followed by a bitwise\r
926 inclusive OR, and writes the result back to the 64-bit I/O port.\r
927\r
928 Reads the 64-bit I/O port specified by Port, performs a bitwise AND between\r
929 the read result and the value specified by AndData, performs a bitwise OR\r
930 between the result of the AND operation and the value specified by OrData,\r
931 and writes the result to the 64-bit I/O port specified by Port. The value\r
932 written to the I/O port is returned. This function must guarantee that all\r
933 I/O read and write operations are serialized.\r
934\r
935 If 64-bit I/O port operations are not supported, then ASSERT().\r
936\r
937 @param Port The I/O port to write.\r
938 @param AndData The value to AND with the read value from the I/O port.\r
939 @param OrData The value to OR with the result of the AND operation.\r
940\r
941 @return The value written back to the I/O port.\r
942\r
943**/\r
944UINT64\r
945EFIAPI\r
946IoAndThenOr64 (\r
947 IN UINTN Port,\r
948 IN UINT64 AndData,\r
949 IN UINT64 OrData\r
950 )\r
951{\r
952 return IoWrite64 (Port, (IoRead64 (Port) & AndData) | OrData);\r
953}\r
954\r
955/**\r
956 Reads a bit field of an I/O register.\r
957\r
958 Reads the bit field in a 64-bit I/O register. The bit field is specified by\r
959 the StartBit and the EndBit. The value of the bit field is returned.\r
960\r
961 If 64-bit I/O port operations are not supported, then ASSERT().\r
962 If StartBit is greater than 63, then ASSERT().\r
963 If EndBit is greater than 63, then ASSERT().\r
964 If EndBit is less than StartBit, then ASSERT().\r
965\r
966 @param Port The I/O port to read.\r
967 @param StartBit The ordinal of the least significant bit in the bit field.\r
968 Range 0..63.\r
969 @param EndBit The ordinal of the most significant bit in the bit field.\r
970 Range 0..63.\r
971\r
972 @return The value read.\r
973\r
974**/\r
975UINT64\r
976EFIAPI\r
977IoBitFieldRead64 (\r
978 IN UINTN Port,\r
979 IN UINTN StartBit,\r
980 IN UINTN EndBit\r
981 )\r
982{\r
983 return BitFieldRead64 (IoRead64 (Port), StartBit, EndBit);\r
984}\r
985\r
986/**\r
987 Writes a bit field to an I/O register.\r
988\r
989 Writes Value to the bit field of the I/O register. The bit field is specified\r
990 by the StartBit and the EndBit. All other bits in the destination I/O\r
991 register are preserved. The value written to the I/O port is returned. Extra\r
992 left bits in Value are stripped.\r
993\r
994 If 64-bit I/O port operations are not supported, then ASSERT().\r
995 If StartBit is greater than 63, then ASSERT().\r
996 If EndBit is greater than 63, then ASSERT().\r
997 If EndBit is less than StartBit, then ASSERT().\r
998\r
999 @param Port The I/O port to write.\r
1000 @param StartBit The ordinal of the least significant bit in the bit field.\r
1001 Range 0..63.\r
1002 @param EndBit The ordinal of the most significant bit in the bit field.\r
1003 Range 0..63.\r
1004 @param Value New value of the bit field.\r
1005\r
1006 @return The value written back to the I/O port.\r
1007\r
1008**/\r
1009UINT64\r
1010EFIAPI\r
1011IoBitFieldWrite64 (\r
1012 IN UINTN Port,\r
1013 IN UINTN StartBit,\r
1014 IN UINTN EndBit,\r
1015 IN UINT64 Value\r
1016 )\r
1017{\r
1018 return IoWrite64 (\r
1019 Port,\r
1020 BitFieldWrite64 (IoRead64 (Port), StartBit, EndBit, Value)\r
1021 );\r
1022}\r
1023\r
1024/**\r
1025 Reads a bit field in a 64-bit port, performs a bitwise OR, and writes the\r
1026 result back to the bit field in the 64-bit port.\r
1027\r
1028 Reads the 64-bit I/O port specified by Port, performs a bitwise inclusive OR\r
1029 between the read result and the value specified by OrData, and writes the\r
1030 result to the 64-bit I/O port specified by Port. The value written to the I/O\r
1031 port is returned. This function must guarantee that all I/O read and write\r
1032 operations are serialized. Extra left bits in OrData are stripped.\r
1033\r
1034 If 64-bit I/O port operations are not supported, then ASSERT().\r
1035 If StartBit is greater than 63, then ASSERT().\r
1036 If EndBit is greater than 63, then ASSERT().\r
1037 If EndBit is less than StartBit, then ASSERT().\r
1038\r
1039 @param Port The I/O port to write.\r
1040 @param StartBit The ordinal of the least significant bit in the bit field.\r
1041 Range 0..63.\r
1042 @param EndBit The ordinal of the most significant bit in the bit field.\r
1043 Range 0..63.\r
1044 @param OrData The value to OR with the read value from the I/O port.\r
1045\r
1046 @return The value written back to the I/O port.\r
1047\r
1048**/\r
1049UINT64\r
1050EFIAPI\r
1051IoBitFieldOr64 (\r
1052 IN UINTN Port,\r
1053 IN UINTN StartBit,\r
1054 IN UINTN EndBit,\r
1055 IN UINT64 OrData\r
1056 )\r
1057{\r
1058 return IoWrite64 (\r
1059 Port,\r
1060 BitFieldOr64 (IoRead64 (Port), StartBit, EndBit, OrData)\r
1061 );\r
1062}\r
1063\r
1064/**\r
1065 Reads a bit field in a 64-bit port, performs a bitwise AND, and writes the\r
1066 result back to the bit field in the 64-bit port.\r
1067\r
1068 Reads the 64-bit I/O port specified by Port, performs a bitwise AND between\r
1069 the read result and the value specified by AndData, and writes the result to\r
1070 the 64-bit I/O port specified by Port. The value written to the I/O port is\r
1071 returned. This function must guarantee that all I/O read and write operations\r
1072 are serialized. Extra left bits in AndData are stripped.\r
1073\r
1074 If 64-bit I/O port operations are not supported, then ASSERT().\r
1075 If StartBit is greater than 63, then ASSERT().\r
1076 If EndBit is greater than 63, then ASSERT().\r
1077 If EndBit is less than StartBit, then ASSERT().\r
1078\r
1079 @param Port The I/O port to write.\r
1080 @param StartBit The ordinal of the least significant bit in the bit field.\r
1081 Range 0..63.\r
1082 @param EndBit The ordinal of the most significant bit in the bit field.\r
1083 Range 0..63.\r
1084 @param AndData The value to AND with the read value from the I/O port.\r
1085\r
1086 @return The value written back to the I/O port.\r
1087\r
1088**/\r
1089UINT64\r
1090EFIAPI\r
1091IoBitFieldAnd64 (\r
1092 IN UINTN Port,\r
1093 IN UINTN StartBit,\r
1094 IN UINTN EndBit,\r
1095 IN UINT64 AndData\r
1096 )\r
1097{\r
1098 return IoWrite64 (\r
1099 Port,\r
1100 BitFieldAnd64 (IoRead64 (Port), StartBit, EndBit, AndData)\r
1101 );\r
1102}\r
1103\r
1104/**\r
1105 Reads a bit field in a 64-bit port, performs a bitwise AND followed by a\r
1106 bitwise inclusive OR, and writes the result back to the bit field in the\r
1107 64-bit port.\r
1108\r
1109 Reads the 64-bit I/O port specified by Port, performs a bitwise AND followed\r
1110 by a bitwise inclusive OR between the read result and the value specified by\r
1111 AndData, and writes the result to the 64-bit I/O port specified by Port. The\r
1112 value written to the I/O port is returned. This function must guarantee that\r
1113 all I/O read and write operations are serialized. Extra left bits in both\r
1114 AndData and OrData are stripped.\r
1115\r
1116 If 64-bit I/O port operations are not supported, then ASSERT().\r
1117 If StartBit is greater than 63, then ASSERT().\r
1118 If EndBit is greater than 63, then ASSERT().\r
1119 If EndBit is less than StartBit, then ASSERT().\r
1120\r
1121 @param Port The I/O port to write.\r
1122 @param StartBit The ordinal of the least significant bit in the bit field.\r
1123 Range 0..63.\r
1124 @param EndBit The ordinal of the most significant bit in the bit field.\r
1125 Range 0..63.\r
1126 @param AndData The value to AND with the read value from the I/O port.\r
1127 @param OrData The value to OR with the result of the AND operation.\r
1128\r
1129 @return The value written back to the I/O port.\r
1130\r
1131**/\r
1132UINT64\r
1133EFIAPI\r
1134IoBitFieldAndThenOr64 (\r
1135 IN UINTN Port,\r
1136 IN UINTN StartBit,\r
1137 IN UINTN EndBit,\r
1138 IN UINT64 AndData,\r
1139 IN UINT64 OrData\r
1140 )\r
1141{\r
1142 return IoWrite64 (\r
1143 Port,\r
1144 BitFieldAndThenOr64 (IoRead64 (Port), StartBit, EndBit, AndData, OrData)\r
1145 );\r
1146}\r
1147\r
1148/**\r
1149 Reads an 8-bit MMIO register, performs a bitwise inclusive OR, and writes the\r
1150 result back to the 8-bit MMIO register.\r
1151\r
1152 Reads the 8-bit MMIO register specified by Address, performs a bitwise\r
1153 inclusive OR between the read result and the value specified by OrData, and\r
1154 writes the result to the 8-bit MMIO register specified by Address. The value\r
1155 written to the MMIO register is returned. This function must guarantee that\r
1156 all MMIO read and write operations are serialized.\r
1157\r
1158 If 8-bit MMIO register operations are not supported, then ASSERT().\r
1159\r
1160 @param Address The MMIO register to write.\r
1161 @param OrData The value to OR with the read value from the MMIO register.\r
1162\r
1163 @return The value written back to the MMIO register.\r
1164\r
1165**/\r
1166UINT8\r
1167EFIAPI\r
1168MmioOr8 (\r
1169 IN UINTN Address,\r
1170 IN UINT8 OrData\r
1171 )\r
1172{\r
1173 return MmioWrite8 (Address, (UINT8) (MmioRead8 (Address) | OrData));\r
1174}\r
1175\r
1176/**\r
1177 Reads an 8-bit MMIO register, performs a bitwise AND, and writes the result\r
1178 back to the 8-bit MMIO register.\r
1179\r
1180 Reads the 8-bit MMIO register specified by Address, performs a bitwise AND\r
1181 between the read result and the value specified by AndData, and writes the\r
1182 result to the 8-bit MMIO register specified by Address. The value written to\r
1183 the MMIO register is returned. This function must guarantee that all MMIO\r
1184 read and write operations are serialized.\r
1185\r
1186 If 8-bit MMIO register operations are not supported, then ASSERT().\r
1187\r
1188 @param Address The MMIO register to write.\r
1189 @param AndData The value to AND with the read value from the MMIO register.\r
1190\r
1191 @return The value written back to the MMIO register.\r
1192\r
1193**/\r
1194UINT8\r
1195EFIAPI\r
1196MmioAnd8 (\r
1197 IN UINTN Address,\r
1198 IN UINT8 AndData\r
1199 )\r
1200{\r
1201 return MmioWrite8 (Address, (UINT8) (MmioRead8 (Address) & AndData));\r
1202}\r
1203\r
1204/**\r
1205 Reads an 8-bit MMIO register, performs a bitwise AND followed by a bitwise\r
1206 inclusive OR, and writes the result back to the 8-bit MMIO register.\r
1207\r
1208 Reads the 8-bit MMIO register specified by Address, performs a bitwise AND\r
1209 between the read result and the value specified by AndData, performs a\r
1210 bitwise OR between the result of the AND operation and the value specified by\r
1211 OrData, and writes the result to the 8-bit MMIO register specified by\r
1212 Address. The value written to the MMIO register is returned. This function\r
1213 must guarantee that all MMIO read and write operations are serialized.\r
1214\r
1215 If 8-bit MMIO register operations are not supported, then ASSERT().\r
1216\r
1217\r
1218 @param Address The MMIO register to write.\r
1219 @param AndData The value to AND with the read value from the MMIO register.\r
1220 @param OrData The value to OR with the result of the AND operation.\r
1221\r
1222 @return The value written back to the MMIO register.\r
1223\r
1224**/\r
1225UINT8\r
1226EFIAPI\r
1227MmioAndThenOr8 (\r
1228 IN UINTN Address,\r
1229 IN UINT8 AndData,\r
1230 IN UINT8 OrData\r
1231 )\r
1232{\r
1233 return MmioWrite8 (Address, (UINT8) ((MmioRead8 (Address) & AndData) | OrData));\r
1234}\r
1235\r
1236/**\r
1237 Reads a bit field of a MMIO register.\r
1238\r
1239 Reads the bit field in an 8-bit MMIO register. The bit field is specified by\r
1240 the StartBit and the EndBit. The value of the bit field is returned.\r
1241\r
1242 If 8-bit MMIO register operations are not supported, then ASSERT().\r
1243 If StartBit is greater than 7, then ASSERT().\r
1244 If EndBit is greater than 7, then ASSERT().\r
1245 If EndBit is less than StartBit, then ASSERT().\r
1246\r
1247 @param Address MMIO register to read.\r
1248 @param StartBit The ordinal of the least significant bit in the bit field.\r
1249 Range 0..7.\r
1250 @param EndBit The ordinal of the most significant bit in the bit field.\r
1251 Range 0..7.\r
1252\r
1253 @return The value read.\r
1254\r
1255**/\r
1256UINT8\r
1257EFIAPI\r
1258MmioBitFieldRead8 (\r
1259 IN UINTN Address,\r
1260 IN UINTN StartBit,\r
1261 IN UINTN EndBit\r
1262 )\r
1263{\r
1264 return BitFieldRead8 (MmioRead8 (Address), StartBit, EndBit);\r
1265}\r
1266\r
1267/**\r
1268 Writes a bit field to a MMIO register.\r
1269\r
1270 Writes Value to the bit field of the MMIO register. The bit field is\r
1271 specified by the StartBit and the EndBit. All other bits in the destination\r
1272 MMIO register are preserved. The new value of the 8-bit register is returned.\r
1273\r
1274 If 8-bit MMIO register operations are not supported, then ASSERT().\r
1275 If StartBit is greater than 7, then ASSERT().\r
1276 If EndBit is greater than 7, then ASSERT().\r
1277 If EndBit is less than StartBit, then ASSERT().\r
1278\r
1279 @param Address MMIO register to write.\r
1280 @param StartBit The ordinal of the least significant bit in the bit field.\r
1281 Range 0..7.\r
1282 @param EndBit The ordinal of the most significant bit in the bit field.\r
1283 Range 0..7.\r
1284 @param Value New value of the bit field.\r
1285\r
1286 @return The value written back to the MMIO register.\r
1287\r
1288**/\r
1289UINT8\r
1290EFIAPI\r
1291MmioBitFieldWrite8 (\r
1292 IN UINTN Address,\r
1293 IN UINTN StartBit,\r
1294 IN UINTN EndBit,\r
1295 IN UINT8 Value\r
1296 )\r
1297{\r
1298 return MmioWrite8 (\r
1299 Address,\r
1300 BitFieldWrite8 (MmioRead8 (Address), StartBit, EndBit, Value)\r
1301 );\r
1302}\r
1303\r
1304/**\r
1305 Reads a bit field in an 8-bit MMIO register, performs a bitwise OR, and\r
1306 writes the result back to the bit field in the 8-bit MMIO register.\r
1307\r
1308 Reads the 8-bit MMIO register specified by Address, performs a bitwise\r
1309 inclusive OR between the read result and the value specified by OrData, and\r
1310 writes the result to the 8-bit MMIO register specified by Address. The value\r
1311 written to the MMIO register is returned. This function must guarantee that\r
1312 all MMIO read and write operations are serialized. Extra left bits in OrData\r
1313 are stripped.\r
1314\r
1315 If 8-bit MMIO register operations are not supported, then ASSERT().\r
1316 If StartBit is greater than 7, then ASSERT().\r
1317 If EndBit is greater than 7, then ASSERT().\r
1318 If EndBit is less than StartBit, then ASSERT().\r
1319\r
1320 @param Address MMIO register to write.\r
1321 @param StartBit The ordinal of the least significant bit in the bit field.\r
1322 Range 0..7.\r
1323 @param EndBit The ordinal of the most significant bit in the bit field.\r
1324 Range 0..7.\r
1325 @param OrData The value to OR with read value from the MMIO register.\r
1326\r
1327 @return The value written back to the MMIO register.\r
1328\r
1329**/\r
1330UINT8\r
1331EFIAPI\r
1332MmioBitFieldOr8 (\r
1333 IN UINTN Address,\r
1334 IN UINTN StartBit,\r
1335 IN UINTN EndBit,\r
1336 IN UINT8 OrData\r
1337 )\r
1338{\r
1339 return MmioWrite8 (\r
1340 Address,\r
1341 BitFieldOr8 (MmioRead8 (Address), StartBit, EndBit, OrData)\r
1342 );\r
1343}\r
1344\r
1345/**\r
1346 Reads a bit field in an 8-bit MMIO register, performs a bitwise AND, and\r
1347 writes the result back to the bit field in the 8-bit MMIO register.\r
1348\r
1349 Reads the 8-bit MMIO register specified by Address, performs a bitwise AND\r
1350 between the read result and the value specified by AndData, and writes the\r
1351 result to the 8-bit MMIO register specified by Address. The value written to\r
1352 the MMIO register is returned. This function must guarantee that all MMIO\r
1353 read and write operations are serialized. Extra left bits in AndData are\r
1354 stripped.\r
1355\r
1356 If 8-bit MMIO register operations are not supported, then ASSERT().\r
1357 If StartBit is greater than 7, then ASSERT().\r
1358 If EndBit is greater than 7, then ASSERT().\r
1359 If EndBit is less than StartBit, then ASSERT().\r
1360\r
1361 @param Address MMIO register to write.\r
1362 @param StartBit The ordinal of the least significant bit in the bit field.\r
1363 Range 0..7.\r
1364 @param EndBit The ordinal of the most significant bit in the bit field.\r
1365 Range 0..7.\r
1366 @param AndData The value to AND with read value from the MMIO register.\r
1367\r
1368 @return The value written back to the MMIO register.\r
1369\r
1370**/\r
1371UINT8\r
1372EFIAPI\r
1373MmioBitFieldAnd8 (\r
1374 IN UINTN Address,\r
1375 IN UINTN StartBit,\r
1376 IN UINTN EndBit,\r
1377 IN UINT8 AndData\r
1378 )\r
1379{\r
1380 return MmioWrite8 (\r
1381 Address,\r
1382 BitFieldAnd8 (MmioRead8 (Address), StartBit, EndBit, AndData)\r
1383 );\r
1384}\r
1385\r
1386/**\r
1387 Reads a bit field in an 8-bit MMIO register, performs a bitwise AND followed\r
1388 by a bitwise inclusive OR, and writes the result back to the bit field in the\r
1389 8-bit MMIO register.\r
1390\r
1391 Reads the 8-bit MMIO register specified by Address, performs a bitwise AND\r
1392 followed by a bitwise inclusive OR between the read result and the value\r
1393 specified by AndData, and writes the result to the 8-bit MMIO register\r
1394 specified by Address. The value written to the MMIO register is returned.\r
1395 This function must guarantee that all MMIO read and write operations are\r
1396 serialized. Extra left bits in both AndData and OrData are stripped.\r
1397\r
1398 If 8-bit MMIO register operations are not supported, then ASSERT().\r
1399 If StartBit is greater than 7, then ASSERT().\r
1400 If EndBit is greater than 7, then ASSERT().\r
1401 If EndBit is less than StartBit, then ASSERT().\r
1402\r
1403 @param Address MMIO register to write.\r
1404 @param StartBit The ordinal of the least significant bit in the bit field.\r
1405 Range 0..7.\r
1406 @param EndBit The ordinal of the most significant bit in the bit field.\r
1407 Range 0..7.\r
1408 @param AndData The value to AND with read value from the MMIO register.\r
1409 @param OrData The value to OR with the result of the AND operation.\r
1410\r
1411 @return The value written back to the MMIO register.\r
1412\r
1413**/\r
1414UINT8\r
1415EFIAPI\r
1416MmioBitFieldAndThenOr8 (\r
1417 IN UINTN Address,\r
1418 IN UINTN StartBit,\r
1419 IN UINTN EndBit,\r
1420 IN UINT8 AndData,\r
1421 IN UINT8 OrData\r
1422 )\r
1423{\r
1424 return MmioWrite8 (\r
1425 Address,\r
1426 BitFieldAndThenOr8 (MmioRead8 (Address), StartBit, EndBit, AndData, OrData)\r
1427 );\r
1428}\r
1429\r
1430/**\r
1431 Reads a 16-bit MMIO register, performs a bitwise inclusive OR, and writes the\r
1432 result back to the 16-bit MMIO register.\r
1433\r
1434 Reads the 16-bit MMIO register specified by Address, performs a bitwise\r
1435 inclusive OR between the read result and the value specified by OrData, and\r
1436 writes the result to the 16-bit MMIO register specified by Address. The value\r
1437 written to the MMIO register is returned. This function must guarantee that\r
1438 all MMIO read and write operations are serialized.\r
1439\r
1440 If 16-bit MMIO register operations are not supported, then ASSERT().\r
1441\r
1442 @param Address The MMIO register to write.\r
1443 @param OrData The value to OR with the read value from the MMIO register.\r
1444\r
1445 @return The value written back to the MMIO register.\r
1446\r
1447**/\r
1448UINT16\r
1449EFIAPI\r
1450MmioOr16 (\r
1451 IN UINTN Address,\r
1452 IN UINT16 OrData\r
1453 )\r
1454{\r
1455 return MmioWrite16 (Address, (UINT16) (MmioRead16 (Address) | OrData));\r
1456}\r
1457\r
1458/**\r
1459 Reads a 16-bit MMIO register, performs a bitwise AND, and writes the result\r
1460 back to the 16-bit MMIO register.\r
1461\r
1462 Reads the 16-bit MMIO register specified by Address, performs a bitwise AND\r
1463 between the read result and the value specified by AndData, and writes the\r
1464 result to the 16-bit MMIO register specified by Address. The value written to\r
1465 the MMIO register is returned. This function must guarantee that all MMIO\r
1466 read and write operations are serialized.\r
1467\r
1468 If 16-bit MMIO register operations are not supported, then ASSERT().\r
1469\r
1470 @param Address The MMIO register to write.\r
1471 @param AndData The value to AND with the read value from the MMIO register.\r
1472\r
1473 @return The value written back to the MMIO register.\r
1474\r
1475**/\r
1476UINT16\r
1477EFIAPI\r
1478MmioAnd16 (\r
1479 IN UINTN Address,\r
1480 IN UINT16 AndData\r
1481 )\r
1482{\r
1483 return MmioWrite16 (Address, (UINT16) (MmioRead16 (Address) & AndData));\r
1484}\r
1485\r
1486/**\r
1487 Reads a 16-bit MMIO register, performs a bitwise AND followed by a bitwise\r
1488 inclusive OR, and writes the result back to the 16-bit MMIO register.\r
1489\r
1490 Reads the 16-bit MMIO register specified by Address, performs a bitwise AND\r
1491 between the read result and the value specified by AndData, performs a\r
1492 bitwise OR between the result of the AND operation and the value specified by\r
1493 OrData, and writes the result to the 16-bit MMIO register specified by\r
1494 Address. The value written to the MMIO register is returned. This function\r
1495 must guarantee that all MMIO read and write operations are serialized.\r
1496\r
1497 If 16-bit MMIO register operations are not supported, then ASSERT().\r
1498\r
1499\r
1500 @param Address The MMIO register to write.\r
1501 @param AndData The value to AND with the read value from the MMIO register.\r
1502 @param OrData The value to OR with the result of the AND operation.\r
1503\r
1504 @return The value written back to the MMIO register.\r
1505\r
1506**/\r
1507UINT16\r
1508EFIAPI\r
1509MmioAndThenOr16 (\r
1510 IN UINTN Address,\r
1511 IN UINT16 AndData,\r
1512 IN UINT16 OrData\r
1513 )\r
1514{\r
1515 return MmioWrite16 (Address, (UINT16) ((MmioRead16 (Address) & AndData) | OrData));\r
1516}\r
1517\r
1518/**\r
1519 Reads a bit field of a MMIO register.\r
1520\r
1521 Reads the bit field in a 16-bit MMIO register. The bit field is specified by\r
1522 the StartBit and the EndBit. The value of the bit field is returned.\r
1523\r
1524 If 16-bit MMIO register operations are not supported, then ASSERT().\r
1525 If StartBit is greater than 15, then ASSERT().\r
1526 If EndBit is greater than 15, then ASSERT().\r
1527 If EndBit is less than StartBit, then ASSERT().\r
1528\r
1529 @param Address MMIO register to read.\r
1530 @param StartBit The ordinal of the least significant bit in the bit field.\r
1531 Range 0..15.\r
1532 @param EndBit The ordinal of the most significant bit in the bit field.\r
1533 Range 0..15.\r
1534\r
1535 @return The value read.\r
1536\r
1537**/\r
1538UINT16\r
1539EFIAPI\r
1540MmioBitFieldRead16 (\r
1541 IN UINTN Address,\r
1542 IN UINTN StartBit,\r
1543 IN UINTN EndBit\r
1544 )\r
1545{\r
1546 return BitFieldRead16 (MmioRead16 (Address), StartBit, EndBit);\r
1547}\r
1548\r
1549/**\r
1550 Writes a bit field to a MMIO register.\r
1551\r
1552 Writes Value to the bit field of the MMIO register. The bit field is\r
1553 specified by the StartBit and the EndBit. All other bits in the destination\r
1554 MMIO register are preserved. The new value of the 16-bit register is returned.\r
1555\r
1556 If 16-bit MMIO register operations are not supported, then ASSERT().\r
1557 If StartBit is greater than 15, then ASSERT().\r
1558 If EndBit is greater than 15, then ASSERT().\r
1559 If EndBit is less than StartBit, then ASSERT().\r
1560\r
1561 @param Address MMIO register to write.\r
1562 @param StartBit The ordinal of the least significant bit in the bit field.\r
1563 Range 0..15.\r
1564 @param EndBit The ordinal of the most significant bit in the bit field.\r
1565 Range 0..15.\r
1566 @param Value New value of the bit field.\r
1567\r
1568 @return The value written back to the MMIO register.\r
1569\r
1570**/\r
1571UINT16\r
1572EFIAPI\r
1573MmioBitFieldWrite16 (\r
1574 IN UINTN Address,\r
1575 IN UINTN StartBit,\r
1576 IN UINTN EndBit,\r
1577 IN UINT16 Value\r
1578 )\r
1579{\r
1580 return MmioWrite16 (\r
1581 Address,\r
1582 BitFieldWrite16 (MmioRead16 (Address), StartBit, EndBit, Value)\r
1583 );\r
1584}\r
1585\r
1586/**\r
1587 Reads a bit field in a 16-bit MMIO register, performs a bitwise OR, and\r
1588 writes the result back to the bit field in the 16-bit MMIO register.\r
1589\r
1590 Reads the 16-bit MMIO register specified by Address, performs a bitwise\r
1591 inclusive OR between the read result and the value specified by OrData, and\r
1592 writes the result to the 16-bit MMIO register specified by Address. The value\r
1593 written to the MMIO register is returned. This function must guarantee that\r
1594 all MMIO read and write operations are serialized. Extra left bits in OrData\r
1595 are stripped.\r
1596\r
1597 If 16-bit MMIO register operations are not supported, then ASSERT().\r
1598 If StartBit is greater than 15, then ASSERT().\r
1599 If EndBit is greater than 15, then ASSERT().\r
1600 If EndBit is less than StartBit, then ASSERT().\r
1601\r
1602 @param Address MMIO register to write.\r
1603 @param StartBit The ordinal of the least significant bit in the bit field.\r
1604 Range 0..15.\r
1605 @param EndBit The ordinal of the most significant bit in the bit field.\r
1606 Range 0..15.\r
1607 @param OrData The value to OR with read value from the MMIO register.\r
1608\r
1609 @return The value written back to the MMIO register.\r
1610\r
1611**/\r
1612UINT16\r
1613EFIAPI\r
1614MmioBitFieldOr16 (\r
1615 IN UINTN Address,\r
1616 IN UINTN StartBit,\r
1617 IN UINTN EndBit,\r
1618 IN UINT16 OrData\r
1619 )\r
1620{\r
1621 return MmioWrite16 (\r
1622 Address,\r
1623 BitFieldOr16 (MmioRead16 (Address), StartBit, EndBit, OrData)\r
1624 );\r
1625}\r
1626\r
1627/**\r
1628 Reads a bit field in a 16-bit MMIO register, performs a bitwise AND, and\r
1629 writes the result back to the bit field in the 16-bit MMIO register.\r
1630\r
1631 Reads the 16-bit MMIO register specified by Address, performs a bitwise AND\r
1632 between the read result and the value specified by AndData, and writes the\r
1633 result to the 16-bit MMIO register specified by Address. The value written to\r
1634 the MMIO register is returned. This function must guarantee that all MMIO\r
1635 read and write operations are serialized. Extra left bits in AndData are\r
1636 stripped.\r
1637\r
1638 If 16-bit MMIO register operations are not supported, then ASSERT().\r
1639 If StartBit is greater than 15, then ASSERT().\r
1640 If EndBit is greater than 15, then ASSERT().\r
1641 If EndBit is less than StartBit, then ASSERT().\r
1642\r
1643 @param Address MMIO register to write.\r
1644 @param StartBit The ordinal of the least significant bit in the bit field.\r
1645 Range 0..15.\r
1646 @param EndBit The ordinal of the most significant bit in the bit field.\r
1647 Range 0..15.\r
1648 @param AndData The value to AND with read value from the MMIO register.\r
1649\r
1650 @return The value written back to the MMIO register.\r
1651\r
1652**/\r
1653UINT16\r
1654EFIAPI\r
1655MmioBitFieldAnd16 (\r
1656 IN UINTN Address,\r
1657 IN UINTN StartBit,\r
1658 IN UINTN EndBit,\r
1659 IN UINT16 AndData\r
1660 )\r
1661{\r
1662 return MmioWrite16 (\r
1663 Address,\r
1664 BitFieldAnd16 (MmioRead16 (Address), StartBit, EndBit, AndData)\r
1665 );\r
1666}\r
1667\r
1668/**\r
1669 Reads a bit field in a 16-bit MMIO register, performs a bitwise AND followed\r
1670 by a bitwise inclusive OR, and writes the result back to the bit field in the\r
1671 16-bit MMIO register.\r
1672\r
1673 Reads the 16-bit MMIO register specified by Address, performs a bitwise AND\r
1674 followed by a bitwise inclusive OR between the read result and the value\r
1675 specified by AndData, and writes the result to the 16-bit MMIO register\r
1676 specified by Address. The value written to the MMIO register is returned.\r
1677 This function must guarantee that all MMIO read and write operations are\r
1678 serialized. Extra left bits in both AndData and OrData are stripped.\r
1679\r
1680 If 16-bit MMIO register operations are not supported, then ASSERT().\r
1681 If StartBit is greater than 15, then ASSERT().\r
1682 If EndBit is greater than 15, then ASSERT().\r
1683 If EndBit is less than StartBit, then ASSERT().\r
1684\r
1685 @param Address MMIO register to write.\r
1686 @param StartBit The ordinal of the least significant bit in the bit field.\r
1687 Range 0..15.\r
1688 @param EndBit The ordinal of the most significant bit in the bit field.\r
1689 Range 0..15.\r
1690 @param AndData The value to AND with read value from the MMIO register.\r
1691 @param OrData The value to OR with the result of the AND operation.\r
1692\r
1693 @return The value written back to the MMIO register.\r
1694\r
1695**/\r
1696UINT16\r
1697EFIAPI\r
1698MmioBitFieldAndThenOr16 (\r
1699 IN UINTN Address,\r
1700 IN UINTN StartBit,\r
1701 IN UINTN EndBit,\r
1702 IN UINT16 AndData,\r
1703 IN UINT16 OrData\r
1704 )\r
1705{\r
1706 return MmioWrite16 (\r
1707 Address,\r
1708 BitFieldAndThenOr16 (MmioRead16 (Address), StartBit, EndBit, AndData, OrData)\r
1709 );\r
1710}\r
1711\r
1712/**\r
1713 Reads a 32-bit MMIO register, performs a bitwise inclusive OR, and writes the\r
1714 result back to the 32-bit MMIO register.\r
1715\r
1716 Reads the 32-bit MMIO register specified by Address, performs a bitwise\r
1717 inclusive OR between the read result and the value specified by OrData, and\r
1718 writes the result to the 32-bit MMIO register specified by Address. The value\r
1719 written to the MMIO register is returned. This function must guarantee that\r
1720 all MMIO read and write operations are serialized.\r
1721\r
1722 If 32-bit MMIO register operations are not supported, then ASSERT().\r
1723\r
1724 @param Address The MMIO register to write.\r
1725 @param OrData The value to OR with the read value from the MMIO register.\r
1726\r
1727 @return The value written back to the MMIO register.\r
1728\r
1729**/\r
1730UINT32\r
1731EFIAPI\r
1732MmioOr32 (\r
1733 IN UINTN Address,\r
1734 IN UINT32 OrData\r
1735 )\r
1736{\r
1737 return MmioWrite32 (Address, MmioRead32 (Address) | OrData);\r
1738}\r
1739\r
1740/**\r
1741 Reads a 32-bit MMIO register, performs a bitwise AND, and writes the result\r
1742 back to the 32-bit MMIO register.\r
1743\r
1744 Reads the 32-bit MMIO register specified by Address, performs a bitwise AND\r
1745 between the read result and the value specified by AndData, and writes the\r
1746 result to the 32-bit MMIO register specified by Address. The value written to\r
1747 the MMIO register is returned. This function must guarantee that all MMIO\r
1748 read and write operations are serialized.\r
1749\r
1750 If 32-bit MMIO register operations are not supported, then ASSERT().\r
1751\r
1752 @param Address The MMIO register to write.\r
1753 @param AndData The value to AND with the read value from the MMIO register.\r
1754\r
1755 @return The value written back to the MMIO register.\r
1756\r
1757**/\r
1758UINT32\r
1759EFIAPI\r
1760MmioAnd32 (\r
1761 IN UINTN Address,\r
1762 IN UINT32 AndData\r
1763 )\r
1764{\r
1765 return MmioWrite32 (Address, MmioRead32 (Address) & AndData);\r
1766}\r
1767\r
1768/**\r
1769 Reads a 32-bit MMIO register, performs a bitwise AND followed by a bitwise\r
1770 inclusive OR, and writes the result back to the 32-bit MMIO register.\r
1771\r
1772 Reads the 32-bit MMIO register specified by Address, performs a bitwise AND\r
1773 between the read result and the value specified by AndData, performs a\r
1774 bitwise OR between the result of the AND operation and the value specified by\r
1775 OrData, and writes the result to the 32-bit MMIO register specified by\r
1776 Address. The value written to the MMIO register is returned. This function\r
1777 must guarantee that all MMIO read and write operations are serialized.\r
1778\r
1779 If 32-bit MMIO register operations are not supported, then ASSERT().\r
1780\r
1781\r
1782 @param Address The MMIO register to write.\r
1783 @param AndData The value to AND with the read value from the MMIO register.\r
1784 @param OrData The value to OR with the result of the AND operation.\r
1785\r
1786 @return The value written back to the MMIO register.\r
1787\r
1788**/\r
1789UINT32\r
1790EFIAPI\r
1791MmioAndThenOr32 (\r
1792 IN UINTN Address,\r
1793 IN UINT32 AndData,\r
1794 IN UINT32 OrData\r
1795 )\r
1796{\r
1797 return MmioWrite32 (Address, (MmioRead32 (Address) & AndData) | OrData);\r
1798}\r
1799\r
1800/**\r
1801 Reads a bit field of a MMIO register.\r
1802\r
1803 Reads the bit field in a 32-bit MMIO register. The bit field is specified by\r
1804 the StartBit and the EndBit. The value of the bit field is returned.\r
1805\r
1806 If 32-bit MMIO register operations are not supported, then ASSERT().\r
1807 If StartBit is greater than 31, then ASSERT().\r
1808 If EndBit is greater than 31, then ASSERT().\r
1809 If EndBit is less than StartBit, then ASSERT().\r
1810\r
1811 @param Address MMIO register to read.\r
1812 @param StartBit The ordinal of the least significant bit in the bit field.\r
1813 Range 0..31.\r
1814 @param EndBit The ordinal of the most significant bit in the bit field.\r
1815 Range 0..31.\r
1816\r
1817 @return The value read.\r
1818\r
1819**/\r
1820UINT32\r
1821EFIAPI\r
1822MmioBitFieldRead32 (\r
1823 IN UINTN Address,\r
1824 IN UINTN StartBit,\r
1825 IN UINTN EndBit\r
1826 )\r
1827{\r
1828 return BitFieldRead32 (MmioRead32 (Address), StartBit, EndBit);\r
1829}\r
1830\r
1831/**\r
1832 Writes a bit field to a MMIO register.\r
1833\r
1834 Writes Value to the bit field of the MMIO register. The bit field is\r
1835 specified by the StartBit and the EndBit. All other bits in the destination\r
1836 MMIO register are preserved. The new value of the 32-bit register is returned.\r
1837\r
1838 If 32-bit MMIO register operations are not supported, then ASSERT().\r
1839 If StartBit is greater than 31, then ASSERT().\r
1840 If EndBit is greater than 31, then ASSERT().\r
1841 If EndBit is less than StartBit, then ASSERT().\r
1842\r
1843 @param Address MMIO register to write.\r
1844 @param StartBit The ordinal of the least significant bit in the bit field.\r
1845 Range 0..31.\r
1846 @param EndBit The ordinal of the most significant bit in the bit field.\r
1847 Range 0..31.\r
1848 @param Value New value of the bit field.\r
1849\r
1850 @return The value written back to the MMIO register.\r
1851\r
1852**/\r
1853UINT32\r
1854EFIAPI\r
1855MmioBitFieldWrite32 (\r
1856 IN UINTN Address,\r
1857 IN UINTN StartBit,\r
1858 IN UINTN EndBit,\r
1859 IN UINT32 Value\r
1860 )\r
1861{\r
1862 return MmioWrite32 (\r
1863 Address,\r
1864 BitFieldWrite32 (MmioRead32 (Address), StartBit, EndBit, Value)\r
1865 );\r
1866}\r
1867\r
1868/**\r
1869 Reads a bit field in a 32-bit MMIO register, performs a bitwise OR, and\r
1870 writes the result back to the bit field in the 32-bit MMIO register.\r
1871\r
1872 Reads the 32-bit MMIO register specified by Address, performs a bitwise\r
1873 inclusive OR between the read result and the value specified by OrData, and\r
1874 writes the result to the 32-bit MMIO register specified by Address. The value\r
1875 written to the MMIO register is returned. This function must guarantee that\r
1876 all MMIO read and write operations are serialized. Extra left bits in OrData\r
1877 are stripped.\r
1878\r
1879 If 32-bit MMIO register operations are not supported, then ASSERT().\r
1880 If StartBit is greater than 31, then ASSERT().\r
1881 If EndBit is greater than 31, then ASSERT().\r
1882 If EndBit is less than StartBit, then ASSERT().\r
1883\r
1884 @param Address MMIO register to write.\r
1885 @param StartBit The ordinal of the least significant bit in the bit field.\r
1886 Range 0..31.\r
1887 @param EndBit The ordinal of the most significant bit in the bit field.\r
1888 Range 0..31.\r
1889 @param OrData The value to OR with read value from the MMIO register.\r
1890\r
1891 @return The value written back to the MMIO register.\r
1892\r
1893**/\r
1894UINT32\r
1895EFIAPI\r
1896MmioBitFieldOr32 (\r
1897 IN UINTN Address,\r
1898 IN UINTN StartBit,\r
1899 IN UINTN EndBit,\r
1900 IN UINT32 OrData\r
1901 )\r
1902{\r
1903 return MmioWrite32 (\r
1904 Address,\r
1905 BitFieldOr32 (MmioRead32 (Address), StartBit, EndBit, OrData)\r
1906 );\r
1907}\r
1908\r
1909/**\r
1910 Reads a bit field in a 32-bit MMIO register, performs a bitwise AND, and\r
1911 writes the result back to the bit field in the 32-bit MMIO register.\r
1912\r
1913 Reads the 32-bit MMIO register specified by Address, performs a bitwise AND\r
1914 between the read result and the value specified by AndData, and writes the\r
1915 result to the 32-bit MMIO register specified by Address. The value written to\r
1916 the MMIO register is returned. This function must guarantee that all MMIO\r
1917 read and write operations are serialized. Extra left bits in AndData are\r
1918 stripped.\r
1919\r
1920 If 32-bit MMIO register operations are not supported, then ASSERT().\r
1921 If StartBit is greater than 31, then ASSERT().\r
1922 If EndBit is greater than 31, then ASSERT().\r
1923 If EndBit is less than StartBit, then ASSERT().\r
1924\r
1925 @param Address MMIO register to write.\r
1926 @param StartBit The ordinal of the least significant bit in the bit field.\r
1927 Range 0..31.\r
1928 @param EndBit The ordinal of the most significant bit in the bit field.\r
1929 Range 0..31.\r
1930 @param AndData The value to AND with read value from the MMIO register.\r
1931\r
1932 @return The value written back to the MMIO register.\r
1933\r
1934**/\r
1935UINT32\r
1936EFIAPI\r
1937MmioBitFieldAnd32 (\r
1938 IN UINTN Address,\r
1939 IN UINTN StartBit,\r
1940 IN UINTN EndBit,\r
1941 IN UINT32 AndData\r
1942 )\r
1943{\r
1944 return MmioWrite32 (\r
1945 Address,\r
1946 BitFieldAnd32 (MmioRead32 (Address), StartBit, EndBit, AndData)\r
1947 );\r
1948}\r
1949\r
1950/**\r
1951 Reads a bit field in a 32-bit MMIO register, performs a bitwise AND followed\r
1952 by a bitwise inclusive OR, and writes the result back to the bit field in the\r
1953 32-bit MMIO register.\r
1954\r
1955 Reads the 32-bit MMIO register specified by Address, performs a bitwise AND\r
1956 followed by a bitwise inclusive OR between the read result and the value\r
1957 specified by AndData, and writes the result to the 32-bit MMIO register\r
1958 specified by Address. The value written to the MMIO register is returned.\r
1959 This function must guarantee that all MMIO read and write operations are\r
1960 serialized. Extra left bits in both AndData and OrData are stripped.\r
1961\r
1962 If 32-bit MMIO register operations are not supported, then ASSERT().\r
1963 If StartBit is greater than 31, then ASSERT().\r
1964 If EndBit is greater than 31, then ASSERT().\r
1965 If EndBit is less than StartBit, then ASSERT().\r
1966\r
1967 @param Address MMIO register to write.\r
1968 @param StartBit The ordinal of the least significant bit in the bit field.\r
1969 Range 0..31.\r
1970 @param EndBit The ordinal of the most significant bit in the bit field.\r
1971 Range 0..31.\r
1972 @param AndData The value to AND with read value from the MMIO register.\r
1973 @param OrData The value to OR with the result of the AND operation.\r
1974\r
1975 @return The value written back to the MMIO register.\r
1976\r
1977**/\r
1978UINT32\r
1979EFIAPI\r
1980MmioBitFieldAndThenOr32 (\r
1981 IN UINTN Address,\r
1982 IN UINTN StartBit,\r
1983 IN UINTN EndBit,\r
1984 IN UINT32 AndData,\r
1985 IN UINT32 OrData\r
1986 )\r
1987{\r
1988 return MmioWrite32 (\r
1989 Address,\r
1990 BitFieldAndThenOr32 (MmioRead32 (Address), StartBit, EndBit, AndData, OrData)\r
1991 );\r
1992}\r
1993\r
1994/**\r
1995 Reads a 64-bit MMIO register, performs a bitwise inclusive OR, and writes the\r
1996 result back to the 64-bit MMIO register.\r
1997\r
1998 Reads the 64-bit MMIO register specified by Address, performs a bitwise\r
1999 inclusive OR between the read result and the value specified by OrData, and\r
2000 writes the result to the 64-bit MMIO register specified by Address. The value\r
2001 written to the MMIO register is returned. This function must guarantee that\r
2002 all MMIO read and write operations are serialized.\r
2003\r
2004 If 64-bit MMIO register operations are not supported, then ASSERT().\r
2005\r
2006 @param Address The MMIO register to write.\r
2007 @param OrData The value to OR with the read value from the MMIO register.\r
2008\r
2009 @return The value written back to the MMIO register.\r
2010\r
2011**/\r
2012UINT64\r
2013EFIAPI\r
2014MmioOr64 (\r
2015 IN UINTN Address,\r
2016 IN UINT64 OrData\r
2017 )\r
2018{\r
2019 return MmioWrite64 (Address, MmioRead64 (Address) | OrData);\r
2020}\r
2021\r
2022/**\r
2023 Reads a 64-bit MMIO register, performs a bitwise AND, and writes the result\r
2024 back to the 64-bit MMIO register.\r
2025\r
2026 Reads the 64-bit MMIO register specified by Address, performs a bitwise AND\r
2027 between the read result and the value specified by AndData, and writes the\r
2028 result to the 64-bit MMIO register specified by Address. The value written to\r
2029 the MMIO register is returned. This function must guarantee that all MMIO\r
2030 read and write operations are serialized.\r
2031\r
2032 If 64-bit MMIO register operations are not supported, then ASSERT().\r
2033\r
2034 @param Address The MMIO register to write.\r
2035 @param AndData The value to AND with the read value from the MMIO register.\r
2036\r
2037 @return The value written back to the MMIO register.\r
2038\r
2039**/\r
2040UINT64\r
2041EFIAPI\r
2042MmioAnd64 (\r
2043 IN UINTN Address,\r
2044 IN UINT64 AndData\r
2045 )\r
2046{\r
2047 return MmioWrite64 (Address, MmioRead64 (Address) & AndData);\r
2048}\r
2049\r
2050/**\r
2051 Reads a 64-bit MMIO register, performs a bitwise AND followed by a bitwise\r
2052 inclusive OR, and writes the result back to the 64-bit MMIO register.\r
2053\r
2054 Reads the 64-bit MMIO register specified by Address, performs a bitwise AND\r
2055 between the read result and the value specified by AndData, performs a\r
2056 bitwise OR between the result of the AND operation and the value specified by\r
2057 OrData, and writes the result to the 64-bit MMIO register specified by\r
2058 Address. The value written to the MMIO register is returned. This function\r
2059 must guarantee that all MMIO read and write operations are serialized.\r
2060\r
2061 If 64-bit MMIO register operations are not supported, then ASSERT().\r
2062\r
2063\r
2064 @param Address The MMIO register to write.\r
2065 @param AndData The value to AND with the read value from the MMIO register.\r
2066 @param OrData The value to OR with the result of the AND operation.\r
2067\r
2068 @return The value written back to the MMIO register.\r
2069\r
2070**/\r
2071UINT64\r
2072EFIAPI\r
2073MmioAndThenOr64 (\r
2074 IN UINTN Address,\r
2075 IN UINT64 AndData,\r
2076 IN UINT64 OrData\r
2077 )\r
2078{\r
2079 return MmioWrite64 (Address, (MmioRead64 (Address) & AndData) | OrData);\r
2080}\r
2081\r
2082/**\r
2083 Reads a bit field of a MMIO register.\r
2084\r
2085 Reads the bit field in a 64-bit MMIO register. The bit field is specified by\r
2086 the StartBit and the EndBit. The value of the bit field is returned.\r
2087\r
2088 If 64-bit MMIO register operations are not supported, then ASSERT().\r
2089 If StartBit is greater than 63, then ASSERT().\r
2090 If EndBit is greater than 63, then ASSERT().\r
2091 If EndBit is less than StartBit, then ASSERT().\r
2092\r
2093 @param Address MMIO register to read.\r
2094 @param StartBit The ordinal of the least significant bit in the bit field.\r
2095 Range 0..63.\r
2096 @param EndBit The ordinal of the most significant bit in the bit field.\r
2097 Range 0..63.\r
2098\r
2099 @return The value read.\r
2100\r
2101**/\r
2102UINT64\r
2103EFIAPI\r
2104MmioBitFieldRead64 (\r
2105 IN UINTN Address,\r
2106 IN UINTN StartBit,\r
2107 IN UINTN EndBit\r
2108 )\r
2109{\r
2110 return BitFieldRead64 (MmioRead64 (Address), StartBit, EndBit);\r
2111}\r
2112\r
2113/**\r
2114 Writes a bit field to a MMIO register.\r
2115\r
2116 Writes Value to the bit field of the MMIO register. The bit field is\r
2117 specified by the StartBit and the EndBit. All other bits in the destination\r
2118 MMIO register are preserved. The new value of the 64-bit register is returned.\r
2119\r
2120 If 64-bit MMIO register operations are not supported, then ASSERT().\r
2121 If StartBit is greater than 63, then ASSERT().\r
2122 If EndBit is greater than 63, then ASSERT().\r
2123 If EndBit is less than StartBit, then ASSERT().\r
2124\r
2125 @param Address MMIO register to write.\r
2126 @param StartBit The ordinal of the least significant bit in the bit field.\r
2127 Range 0..63.\r
2128 @param EndBit The ordinal of the most significant bit in the bit field.\r
2129 Range 0..63.\r
2130 @param Value New value of the bit field.\r
2131\r
2132 @return The value written back to the MMIO register.\r
2133\r
2134**/\r
2135UINT64\r
2136EFIAPI\r
2137MmioBitFieldWrite64 (\r
2138 IN UINTN Address,\r
2139 IN UINTN StartBit,\r
2140 IN UINTN EndBit,\r
2141 IN UINT64 Value\r
2142 )\r
2143{\r
2144 return MmioWrite64 (\r
2145 Address,\r
2146 BitFieldWrite64 (MmioRead64 (Address), StartBit, EndBit, Value)\r
2147 );\r
2148}\r
2149\r
2150/**\r
2151 Reads a bit field in a 64-bit MMIO register, performs a bitwise OR, and\r
2152 writes the result back to the bit field in the 64-bit MMIO register.\r
2153\r
2154 Reads the 64-bit MMIO register specified by Address, performs a bitwise\r
2155 inclusive OR between the read result and the value specified by OrData, and\r
2156 writes the result to the 64-bit MMIO register specified by Address. The value\r
2157 written to the MMIO register is returned. This function must guarantee that\r
2158 all MMIO read and write operations are serialized. Extra left bits in OrData\r
2159 are stripped.\r
2160\r
2161 If 64-bit MMIO register operations are not supported, then ASSERT().\r
2162 If StartBit is greater than 63, then ASSERT().\r
2163 If EndBit is greater than 63, then ASSERT().\r
2164 If EndBit is less than StartBit, then ASSERT().\r
2165\r
2166 @param Address MMIO register to write.\r
2167 @param StartBit The ordinal of the least significant bit in the bit field.\r
2168 Range 0..63.\r
2169 @param EndBit The ordinal of the most significant bit in the bit field.\r
2170 Range 0..63.\r
2171 @param OrData The value to OR with read value from the MMIO register.\r
2172\r
2173 @return The value written back to the MMIO register.\r
2174\r
2175**/\r
2176UINT64\r
2177EFIAPI\r
2178MmioBitFieldOr64 (\r
2179 IN UINTN Address,\r
2180 IN UINTN StartBit,\r
2181 IN UINTN EndBit,\r
2182 IN UINT64 OrData\r
2183 )\r
2184{\r
2185 return MmioWrite64 (\r
2186 Address,\r
2187 BitFieldOr64 (MmioRead64 (Address), StartBit, EndBit, OrData)\r
2188 );\r
2189}\r
2190\r
2191/**\r
2192 Reads a bit field in a 64-bit MMIO register, performs a bitwise AND, and\r
2193 writes the result back to the bit field in the 64-bit MMIO register.\r
2194\r
2195 Reads the 64-bit MMIO register specified by Address, performs a bitwise AND\r
2196 between the read result and the value specified by AndData, and writes the\r
2197 result to the 64-bit MMIO register specified by Address. The value written to\r
2198 the MMIO register is returned. This function must guarantee that all MMIO\r
2199 read and write operations are serialized. Extra left bits in AndData are\r
2200 stripped.\r
2201\r
2202 If 64-bit MMIO register operations are not supported, then ASSERT().\r
2203 If StartBit is greater than 63, then ASSERT().\r
2204 If EndBit is greater than 63, then ASSERT().\r
2205 If EndBit is less than StartBit, then ASSERT().\r
2206\r
2207 @param Address MMIO register to write.\r
2208 @param StartBit The ordinal of the least significant bit in the bit field.\r
2209 Range 0..63.\r
2210 @param EndBit The ordinal of the most significant bit in the bit field.\r
2211 Range 0..63.\r
2212 @param AndData The value to AND with read value from the MMIO register.\r
2213\r
2214 @return The value written back to the MMIO register.\r
2215\r
2216**/\r
2217UINT64\r
2218EFIAPI\r
2219MmioBitFieldAnd64 (\r
2220 IN UINTN Address,\r
2221 IN UINTN StartBit,\r
2222 IN UINTN EndBit,\r
2223 IN UINT64 AndData\r
2224 )\r
2225{\r
2226 return MmioWrite64 (\r
2227 Address,\r
2228 BitFieldAnd64 (MmioRead64 (Address), StartBit, EndBit, AndData)\r
2229 );\r
2230}\r
2231\r
2232/**\r
2233 Reads a bit field in a 64-bit MMIO register, performs a bitwise AND followed\r
2234 by a bitwise inclusive OR, and writes the result back to the bit field in the\r
2235 64-bit MMIO register.\r
2236\r
2237 Reads the 64-bit MMIO register specified by Address, performs a bitwise AND\r
2238 followed by a bitwise inclusive OR between the read result and the value\r
2239 specified by AndData, and writes the result to the 64-bit MMIO register\r
2240 specified by Address. The value written to the MMIO register is returned.\r
2241 This function must guarantee that all MMIO read and write operations are\r
2242 serialized. Extra left bits in both AndData and OrData are stripped.\r
2243\r
2244 If 64-bit MMIO register operations are not supported, then ASSERT().\r
2245 If StartBit is greater than 63, then ASSERT().\r
2246 If EndBit is greater than 63, then ASSERT().\r
2247 If EndBit is less than StartBit, then ASSERT().\r
2248\r
2249 @param Address MMIO register to write.\r
2250 @param StartBit The ordinal of the least significant bit in the bit field.\r
2251 Range 0..63.\r
2252 @param EndBit The ordinal of the most significant bit in the bit field.\r
2253 Range 0..63.\r
2254 @param AndData The value to AND with read value from the MMIO register.\r
2255 @param OrData The value to OR with the result of the AND operation.\r
2256\r
2257 @return The value written back to the MMIO register.\r
2258\r
2259**/\r
2260UINT64\r
2261EFIAPI\r
2262MmioBitFieldAndThenOr64 (\r
2263 IN UINTN Address,\r
2264 IN UINTN StartBit,\r
2265 IN UINTN EndBit,\r
2266 IN UINT64 AndData,\r
2267 IN UINT64 OrData\r
2268 )\r
2269{\r
2270 return MmioWrite64 (\r
2271 Address,\r
2272 BitFieldAndThenOr64 (MmioRead64 (Address), StartBit, EndBit, AndData, OrData)\r
2273 );\r
2274}\r