Write a PS/2 Keyboard Driver

Topic Overview

PS/2 Scancode Path

Keyboards send scancode bytes on IRQ1 from the 8042 controller. Make/break codes map through translation tables to ASCII for simple text mode shells.

Controller Protocol

Read path:

• Wait for output buffer full bit in status port 0x64
• Read scancode from data port 0x60
• Translate set1/set2 with shift/ctrl modifiers

For example, scancode 0x1E press with shift held may yield uppercase A in your lookup table.

Why This Matters in Production

The PS/2 scan-code translation you implement here , make codes, break codes, the shift/caps-lock XOR trick , is exactly what every BIOS and early Linux console driver did before USB HID keyboards became standard. Confusing a break code for a make code is a classic bug that makes a kernel think a key is still held down forever after it's released.

Debugging Checklist

Before you call the implementation done, walk failure modes on purpose. Test empty structures, single-element edge cases, maximum concurrency, and errno paths that must not crash the program. OS code usually fails in production when happy-path tests pass but invariants break under contention or memory pressure.

Implementation Notes

Keep structures small and name fields after kernel counterparts when possible. That lets you read man pages and kernel source side by side while you work. Print observable events during development; remove noisy logs once tests pass reliably.

For This Exercise

You will handle IRQ1, maintain modifier state, and push translated characters into a ring buffer. The task asks you to ignore break codes without duplicating key events.

Your Task

Write the core of a PS/2 keyboard driver. The keyboard sends scan codes (set 1), not characters. A key press sends its make code, and releasing it sends the break code, which is the make code + 0x80. Some keys send a 0xE0 prefix first. The driver tracks modifier state (Shift, Ctrl, Alt, Caps Lock), translates make codes into characters through lookup tables, and stores them in a fixed-size circular buffer that the kernel reads later. If the buffer is full, new keys are dropped.

Input

cCopy
Loading…

Translation (US layout, set 1)

Modifiers: Left Shift 0x2A, Right Shift 0x36, Ctrl 0x1D, Alt 0x38 (held while pressed), and Caps Lock 0x3A (toggles on each press). With 0xE0: 1D right Ctrl, 38 right Alt, 48 <UP>, 50 <DOWN>, 4B <LEFT>, 4D <RIGHT>, 47 <HOME>, 4F <END>, 53 <DEL>.

Rules

• Break codes (bit 7 set) only matter for modifiers; releasing any other key does nothing.
• Caps Lock inverts the case of letters only, so Shift+Caps gives lower case.
• Ctrl + letter → ^X (upper-case letter). Alt prefixes any key with M-.
• Enter, Backspace, Tab and Esc are stored as \n, \b, \t and <ESC>.
• Unknown make codes (and unknown E0 codes) are ignored and counted.
• A key produced while the buffer is full is dropped and counted.

Output

cCopy
Loading…

read concatenates the stored keys exactly as written above. Nothing is printed for the scan codes themselves.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Two 58-entry lookup tables (normal and shifted) indexed by make code, and a circular buffer with head and count.
2. Remember a pending 0xE0 prefix across bytes (and across lines).

Hidden tests cover Caps Lock with and without Shift, Ctrl and Alt combinations, arrow keys, buffer overflow, symbols on the number row, and unknown scan codes.