Peripheral Devices

Introduction

Peripheral devices are everything connected to the computer that is not the CPU or main memory. Your keyboard, mouse, monitor, printer, hard drive, webcam — all peripherals. From a computer architecture perspective, the interesting question is: how does the CPU communicate with devices that have vastly different speeds, data formats, and timing requirements? A keyboard generates a few bytes per second; a graphics card needs gigabytes per second. The I/O system must handle both elegantly. Let's explore how peripherals work and how they connect to the rest of the system.

Classification of Peripheral Devices

By Function

By Data Transfer Speed

By Connection Type

• Internal: Connected directly to motherboard (RAM, CPU fan, internal SSD)
• External: Connected via cables/wireless (keyboard, external monitor, USB drives)
• Integrated: Built into the system (laptop screen, trackpad, speakers)

How Peripherals Communicate

Device Controller

Every peripheral has a device controller — a small piece of hardware that bridges the gap between the device's internal operation and the system bus:

The CPU communicates with peripherals through the controller's registers:

• Data Register: Holds data being transferred (read or write)
• Status Register: Indicates device state (busy, ready, error)
• Control Register: CPU writes commands here (start, stop, mode)

I/O Address Space

Two approaches for CPU to access device registers:

Memory-Mapped I/O (ARM, modern systems):

• Device registers appear as memory addresses
• Use regular LOAD/STORE instructions
• Example: Writing to address 0xFF200000 actually sends data to a serial port
• Advantage: No special I/O instructions needed, same addressing modes available

Isolated I/O / Port-Mapped I/O (x86):

• Separate address space for I/O devices
• Special IN/OUT instructions
• Example: OUT 0x3F8, AL sends byte to COM1 serial port
• Advantage: Smaller addresses (16-bit port space), clear distinction in code

Input Devices Deep Dive

Keyboard

Architecture students should understand the keyboard at the hardware level:

1. Key Press: Mechanical switch closes, row/column intersection detected
2. Scan Code: Keyboard controller generates a scan code (e.g., 0x1E for 'A')
3. Interrupt: Keyboard controller raises IRQ1 on the interrupt controller
4. ISR: CPU runs keyboard interrupt service routine
5. Translation: OS translates scan code to character (considering Shift, Caps Lock, layout)

Mouse

Modern optical/laser mice:

1. Camera takes 1000+ pictures/second of the surface below
2. Image processing chip detects movement direction and distance
3. Delta (dx, dy) values sent to computer via USB (polling at 125-1000 Hz)
4. OS updates cursor position: new_x = old_x + dx

Output Devices Deep Dive

Display (Monitor)

A display receives pixel data from the GPU:

• Resolution: 1920×1080 at 32-bit color = 1920 × 1080 × 4 = ~8 MB per frame
• Bandwidth needed: 8 MB × 60 fps = 480 MB/s (why DisplayPort/HDMI need high bandwidth)
• Refresh rate: How many times per second the screen redraws (60 Hz, 144 Hz, 240 Hz)

Printer

A laser printer operates in these steps:

1. Processing: CPU/Controller rasterizes page (converts text/images to dot matrix)
2. Charging: Photosensitive drum charged uniformly
3. Exposing: Laser writes image by discharging specific points
4. Developing: Toner attracted to discharged areas
5. Transferring: Toner transferred to paper
6. Fusing: Heat melts toner permanently onto paper

The printer has its own CPU and memory (often several hundred MB) to rasterize full pages before printing.

Storage Devices

Hard Disk Drive (HDD)

Solid State Drive (SSD)

SSDs use NAND flash memory — no moving parts:

• Read latency: ~50 μs (100× faster than HDD)
• Write latency: ~200 μs
• Sequential read: 500 MB/s (SATA) to 7000 MB/s (NVMe PCIe 4.0)
• No seek time or rotational latency!

The SSD controller handles: wear leveling, garbage collection, error correction (ECC), and the Flash Translation Layer (FTL) that maps logical blocks to physical flash pages.

Data Transfer Rates Comparison

This 6-orders-of-magnitude range in speeds is why different I/O methods (polling, interrupts, DMA) exist — no single method is optimal for all devices.

Real-World Example: What Happens When You Press a Key

Let's trace the full path from keypress to character on screen:

1. Physical switch closes under your finger (mechanical event)
2. Keyboard controller detects press, generates scan code
3. USB controller packages scan code into USB packet
4. USB host controller in computer receives packet, raises interrupt
5. CPU interrupt handler reads USB data, identifies keyboard event
6. OS keyboard driver translates scan code to character ('A')
7. Application receives character, updates its data structure
8. Application tells window system to redraw
9. GPU renders updated text into frame buffer
10. Display controller reads frame buffer, sends to monitor
11. You see 'A' appear on screen (~10-50 ms total latency)

Key Takeaways

1. Every peripheral has a device controller with data, status, and control registers — the CPU accesses these registers to communicate
2. Device speeds vary by 6+ orders of magnitude — requiring different I/O techniques (polling for slow, DMA for fast)
3. Memory-mapped I/O maps device registers into the memory address space, while port-mapped I/O uses a separate I/O address space
4. Storage devices are both input and output — they store data written by the CPU and provide data when read
5. The complete path from physical input to visible output involves dozens of hardware and software components working in coordination
6. Understanding peripherals at the hardware level explains why I/O is often the bottleneck in system performance