ハードウェアへの直接アクセス

In this lesson, we'll dive into how a CPU directly communicates with hardware devices. While your operating system usually handles this, kernel-level code and device drivers need to talk directly to components like network cards, graphics processors, or storage controllers.

This direct interaction is a powerful, low-level capability that forms the backbone of how your computer functions.

The x86 architecture provides two main methods for the CPU to communicate with peripheral devices:

• I/O Ports: A dedicated, separate address space.
• Memory-Mapped I/O (MMIO): Device registers appear as locations within the CPU's main memory address space.

Both allow the CPU to read from and write to device registers, but they use different mechanisms and instructions.

I/O ports are a special 64KB address space, completely separate from the main memory addresses. Devices map their internal registers to specific port addresses.

Think of them like a set of mailboxes, each with a unique number, where the CPU and devices can exchange small pieces of data. These are often used by older or simpler devices, or for basic control functions.

To read data from an I/O port, x86 assembly uses the IN instruction. This instruction takes the port address (usually in the DX register) and transfers data into an accumulator register (AL, AX, or EAX).

• IN AL, DX: Reads 1 byte from port DX into AL.
• IN AX, DX: Reads 2 bytes from port DX into AX.
• IN EAX, DX: Reads 4 bytes from port DX into EAX.

To write data to an I/O port, we use the OUT instruction. It sends data from an accumulator register to the specified port address (again, typically in DX).

• OUT DX, AL: Writes 1 byte from AL to port DX.
• OUT DX, AX: Writes 2 bytes from AX to port DX.
• OUT DX, EAX: Writes 4 bytes from EAX to port DX.

Here's a conceptual example of how IN and OUT might be used together to interact with a simple device, like a UART (Universal Asynchronous Receiver/Transmitter) for serial communication. Remember, these operations require kernel privileges!

Memory-Mapped I/O (MMIO) is a more modern and common way for the CPU to interact with devices. Instead of a separate I/O port space, device registers are mapped directly into the CPU's physical memory address space.

This means the CPU can access device registers using the same load and store instructions (like MOV) it uses for regular RAM, making it often faster and more flexible for complex devices like GPUs and network cards.

Since MMIO locations appear as regular memory addresses, you don't need special IN/OUT instructions. You simply use standard memory access instructions like MOV to read from or write to these addresses.

The operating system kernel is responsible for setting up these memory mappings so that driver code can access them.

Let's summarize the key differences:

• I/O Ports: Separate address space, uses IN/OUT instructions, often for simpler or legacy devices (e.g., PIC, PIT).
• MMIO: Part of the main memory address space, uses standard MOV instructions, preferred for modern, high-speed, and complex devices (e.g., GPUs, NICs).

MMIO generally offers better performance and easier programming due to using the CPU's optimized memory access mechanisms.

It's crucial to understand that direct hardware access, whether via I/O ports or MMIO, is a highly privileged operation. User-mode programs are prevented from performing these actions directly for security and system stability.

The operating system kernel acts as the gatekeeper, providing controlled interfaces (like system calls or device drivers) for user applications to interact with hardware safely.

You've learned about the two primary ways to directly interact with hardware in x86 assembly from a kernel perspective:

• I/O Ports: A separate address space accessed with IN and OUT instructions.
• Memory-Mapped I/O (MMIO): Device registers mapped into main memory, accessed with standard MOV instructions.

Remember that these powerful techniques are reserved for kernel-level code and device drivers to maintain system integrity and security.