{/* HEADER */}

// software · arm linux · c · kbuild The game, in C. The HPS runs Linux. A C program (./pvz) calls a kernel module (pvz_driver.ko) over /dev/pvz. The kernel module pokes the FPGA's memory-mapped registers. The whole loop fits in seven small files and runs at a steady 60 Hz.

FPS · 60 GRID · 4 × 8 SUN · +25 / 8s PEA · 2 px / frame ZOMBIE · 1 px / 3 frames

{/* SW STACK */}

// the stack Userspace, kernel, register file.

{/* GAME LOOP */}

// main.c The 60 Hz loop.

main.c opens /dev/pvz, the keyboard, and runs an ordinary while(1) with a sleep at the end. No vsync interrupt, no real-time scheduler — Linux's nanosleep is good enough for this one.

Every iteration is the same four steps: poll input, update state, render shapes, commit. The FPGA latches the new shape table at the next vertical blank.

main.c game.c render.c input.c

{`int fd_pvz = open("/dev/pvz", O_RDWR); int fd_kbd = input_open("/dev/input/event0"); game_state_t gs; game_init(&gs); const long ns_per_frame = 16666666; /* ~60 Hz */ struct timespec t0, t1; while (gs.state == STATE_PLAYING) { clock_gettime(CLOCK_MONOTONIC, &t0); /* 1. read keyboard, update cursor / place / remove */ input_poll(fd_kbd, &gs); /* 2. tick the world */ game_update(&gs); /* 3. translate state → shape table over ioctl */ render_frame(fd_pvz, &gs); /* 4. tell the FPGA "swap on next vsync" */ ioctl(fd_pvz, PVZ_COMMIT_SHAPES); /* 5. sleep until the next 16.67 ms tick */ clock_gettime(CLOCK_MONOTONIC, &t1); nanosleep(&(struct timespec){ .tv_nsec = ns_per_frame - elapsed(&t0, &t1) }, NULL); }`}

{/* GAME RULES */}

// game.h — the constants that define the game Numbers worth knowing.

{/* IOCTL INTERFACE */}

// pvz.h — kernel ↔ userspace Three ioctls.
One device node. The kernel module is a misc device. Userspace opens /dev/pvz and writes shapes through structured ioctls. The driver translates each call into 1–3 word writes on the lightweight Avalon-MM bridge.

{`/* Avalon register byte offsets */ #define PVZ_BG_CELL 0x00 #define PVZ_SHAPE_ADDR 0x04 #define PVZ_SHAPE_DATA0 0x08 #define PVZ_SHAPE_DATA1 0x0C #define PVZ_SHAPE_COMMIT 0x10 /* Shape types */ #define SHAPE_RECT 0 #define SHAPE_CIRCLE 1 #define SHAPE_DIGIT 2 #define SHAPE_SPRITE 3 typedef struct { unsigned char index; unsigned char type; unsigned char visible; unsigned short x; unsigned short y; unsigned short w; unsigned short h; unsigned char color; } pvz_shape_arg_t; #define PVZ_MAGIC 'p' #define PVZ_WRITE_BG _IOW(PVZ_MAGIC, 1, pvz_bg_arg_t) #define PVZ_WRITE_SHAPE _IOW(PVZ_MAGIC, 2, pvz_shape_arg_t) #define PVZ_COMMIT_SHAPES _IO( PVZ_MAGIC, 3)`}

{/* RENDER STAGE */}

// render.c — translating game state to pixels State → shape table.

The C side never touches a pixel. render.c walks the game state in a fixed order and emits up to 48 shape descriptors. Indices are reserved by category so z-order is predictable: lawn cells first, plants, zombies, peas, then HUD on top.

{`/* render plants — indices 0..31 */ for (int r = 0; r < GRID_ROWS; r++) { for (int c = 0; c < GRID_COLS; c++) { plant_t *p = &gs->grid[r][c]; pvz_shape_arg_t s = { .index = r * GRID_COLS + c, .type = SHAPE_RECT, .visible = (p->type == PLANT_PEASHOOTER), .x = c * CELL_WIDTH + 12, .y = GAME_AREA_Y + r * CELL_HEIGHT + 14, .w = 56, .h = 60, .color = 7, /* pal[7] = green */ }; ioctl(fd, PVZ_WRITE_SHAPE, &s); } } /* render zombies — indices 32..36 */ for (int i = 0; i < MAX_ZOMBIES; i++) { zombie_t *z = &gs->zombies[i]; pvz_shape_arg_t s = { .index = 32 + i, .type = SHAPE_RECT, .visible = z->active, .x = z->x_pixel, .y = GAME_AREA_Y + z->row * CELL_HEIGHT + 10, .w = ZOMBIE_WIDTH, .h = ZOMBIE_HEIGHT, .color = 5, /* pal[5] = red */ }; ioctl(fd, PVZ_WRITE_SHAPE, &s); } /* render peas, cursor, HUD digits ... */`}

{/* DRIVER */}

// pvz_driver.c — kernel module A misc device, ~150 lines.

The platform driver matches a device-tree compatible string of "csee4840,pvz_gpu-1.0", ioremaps the FPGA peripheral region (around 0xff200000), and registers a misc device at /dev/pvz. unlocked_ioctl dispatches the three commands.

Build with the kernel headers on the board's running kernel; load with insmod. Verify probe success with dmesg | tail and cat /proc/iomem.

{`# on the DE1-SoC, after copying pvz_driver.ko & pvz to / $ insmod pvz_driver.ko $ dmesg | tail [ 142.310] pvz_driver: probed at 0xff200000 $ ls /dev/pvz /dev/pvz $ ./pvz`}

{`static long pvz_ioctl(struct file *f, unsigned int cmd, unsigned long arg) { pvz_shape_arg_t s; pvz_bg_arg_t b; void __iomem *base = pvz.base; switch (cmd) { case PVZ_WRITE_BG: if (copy_from_user(&b, (void __user *)arg, sizeof(b))) return -EFAULT; iowrite32((b.row << 16) | (b.col << 8) | b.color, base + PVZ_BG_CELL); return 0; case PVZ_WRITE_SHAPE: if (copy_from_user(&s, (void __user *)arg, sizeof(s))) return -EFAULT; iowrite32(s.index, base + PVZ_SHAPE_ADDR); iowrite32(pack_data0(&s), base + PVZ_SHAPE_DATA0); iowrite32(pack_data1(&s), base + PVZ_SHAPE_DATA1); return 0; case PVZ_COMMIT_SHAPES: iowrite32(1, base + PVZ_SHAPE_COMMIT); return 0; } return -EINVAL; }`}

{/* TESTS */}

// tests · 12 cases · srand(42) Twelve unit tests for the game loop.

test_game is a pure-C harness over game.c with no hardware dependency. Run on any Linux machine. Deterministic via srand(42). Plus on-board test programs (test_shapes, test_input) that exercise the driver directly.

{`$ make test_game && ./test_game [ ok ] test_init [ ok ] test_place_plant [ ok ] test_remove_plant [ ok ] test_sun_economy [ ok ] test_collision [ ok ] test_zombie_death [ ok ] test_lose_condition [ ok ] test_win_condition [ ok ] test_zombie_stops_at_plant [ ok ] test_zombie_eats_and_destroys_plant [ ok ] test_zombie_resumes_after_eating [ ok ] test_two_zombies_eat_same_plant 12 passed, 0 failed`}

{[ ["test_init", "sun=100 · state=PLAYING · cursor (0,0) · grid empty"], ["test_place_plant", "plant lands · sun−=50 · rejects duplicate / low sun"], ["test_remove_plant", "removes plant · rejects empty cell"], ["test_sun_economy", "+25 every 480 frames"], ["test_collision", "pea hits zombie in same row · −1 HP · pea inactive"], ["test_zombie_death", "1 HP zombie dies on next hit"], ["test_lose_condition", "any zombie at x ≤ 0 → LOSE"], ["test_win_condition", "all 5 spawned and killed → WIN"], ["test_zombie_stops_at_plant", "zombie enters plant cell · starts eating"], ["test_zombie_eats_and_destroys_plant", "DOT until plant HP=0 · plant gone"], ["test_zombie_resumes_after_eating", "clears eat state · resumes walk"], ["test_two_zombies_eat_same_plant", "both eat one plant · both resume"], ].map(([n, d]) => (

OK {n}

{d}

))}