Memory-mapped I/O

Learn memory-mapped I/O and volatile usage.

Memory-mapped I/O

Memory-mapped I/O (MMIO) is the technique where hardware registers are mapped to memory addresses. Writing to a specific address controls hardware; reading from it gives hardware state. Example: 0x40021000 might be a GPIO register.

In C++ these addresses are accessed with volatile std::uint32_t*: volatile std::uint32_t* reg = reinterpret_cast<volatile std::uint32_t*>(0x40021000);. volatile tells the compiler not to optimize this access. Write with *reg = 0x1;, read with *reg.

Why volatile is needed

The compiler optimizer may cache a value if it reads a variable repeatedly. But a hardware register may return different values on each read (a status flag, for example). So volatile forces every read to go to memory.

Likewise repeated writes may be optimized; the optimizer thinks only the last write matters. But every write to hardware is a side effect; it must not be skipped. volatile keeps these writes too. That is why MMIO requires volatile.

Exercise Write an MMIO simulation

Define a global std::uint32_t storage = 0;. Then write volatile std::uint32_t* reg = reinterpret_cast<volatile std::uint32_t*>(&storage);. In main write *reg = 0x1; and std::cout << *reg;.

Show example solution

#include <iostream>
#include <cstdint>

std::uint32_t storage = 0;
volatile std::uint32_t* reg = reinterpret_cast<volatile std::uint32_t*>(&storage);

int main() {
    *reg = 0x1;
    std::cout << *reg;
    return 0;
}

Test yourself

Complete the volatile pointer

volatile std::uint32_t* ____ = reinterpret_cast<volatile std::uint32_t*>(0x40021000);

Show answer

volatile std::uint32_t* reg = reinterpret_cast<volatile std::uint32_t*>(0x40021000);

What does volatile prevent?
```
volatile std::uint32_t* reg = ...;
*reg = 0x1;
*reg = 0x2;  // two writes
```
- Class creation
- Memory leaks
- Run-time errors
- Compiler read/write optimization
Show answer

Compiler read/write optimization — volatile forces every read and write to go to memory.
Match each piece to its role

volatile

Every access goes to memory
MMIO

Map hardware to memory
reinterpret_cast

Cast address to pointer
0x40021000

Hardware register address

Next lesson: Free-standing

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies