Get in touch

Embedded software
engineer

DYLAN TRAN

Bootloaders, kernel drivers & FPGA logic
— from the reset vector to userspace.

Scroll to explore

( Profile )

I work in the layer where the datasheet is the documentation.

Most of what I build runs before an operating system exists: reset vectors, DDR training sequences, flash partition tables, and bootloaders that have to survive a failed update and come back anyway. Office printers, automotive silicon bring-up, aerospace flight hardware — different industries, same question every time. Why won't this board boot?

I studied Electrical Engineering at UBC, then joined three teams in a row whose job was to make new silicon come up reliably — and to write down how, so the next engineer doesn't start from zero.

Boot. Bring-up. Ship.

From reset vector to userspace

( What I do )

Four things I am usually doing to a board.

01

Boot & recovery

The chain from power-on to a running image: TF-A, U-Boot, FSBL and image selectors. I design flash layouts with backup and recovery images, fallback registers that catch a bad update, and secure boot flows that check integrity and authenticity before anything gets executed.

02

BSP & kernel drivers

Board support below the application: memory maps and repartitioning, QSPI and NOR flash drivers, hibernation snapshots to SD and SSD, device tree, and Yocto or Buildroot images that reproduce byte-for-byte on the next machine.

03

Bare-metal & RTOS

No operating system between me and the register map. Cortex-R and Cortex-M firmware on FreeRTOS or none at all, SPI/I2C/UART/CAN peripheral drivers, SCP power and clock domains over SCMI, and MATLAB control algorithms ported down into embedded C.

04

FPGA & programmable logic

Custom logic in the PL and the software that talks to it. AXI blocks that parse UART GNSS and IMU streams and hand encoded messages to the processing system through a queue, plus memory controllers and SPI, I2C and CAN cores written in Verilog and VHDL.

( Hardware )

Nine boards, four ways of thinking about them.

Every family below asks for a different mental model — a scheduler and a page table on one end, a hand-counted interrupt latency on the other. These are the ones I keep going back to.

A / Embedded Linux

Single-board computers

Full Linux on an application processor. Mainline kernels, device tree, U-Boot on removable media, and reproducible root filesystems built with Yocto or Buildroot.

Raspberry Pi board illustration

Raspberry Pi

BCM2711 · Cortex-A72

The fastest path from an idea to a booting Linux system. Kernel modules, device tree overlays and GPIO work before the real target exists.

BeagleBone board illustration

BeagleBone

AM335x · Cortex-A8

A TI application processor with expansion headers on both edges — U-Boot, eMMC versus microSD boot paths, and PRU-adjacent I/O.

B / Bare-metal

Microcontrollers & automotive silicon

No kernel, no allocator, no safety net. Startup code, interrupt vectors, peripheral drivers written straight against the register map — and FreeRTOS when the timing demands it.

Renesas R-Car SoC illustration

Renesas R-Car

X5H / X5L · SCP

Automotive SoC bring-up: C code for power and clock domains on the System Control Processor, with SCMI transactions traced through SCP and kernel logs.

STM32 board illustration

STM32

Cortex-M · HAL / register

The workhorse 32-bit MCU. Clock trees, DMA, timers and comms peripherals — debugged over SWD with a logic analyser on the bench.

ESP32 module illustration

ESP32

Xtensa LX6 · Wi-Fi / BLE

Dual-core MCU with a radio attached. ESP-IDF and FreeRTOS tasks for connected sensor nodes and quick wireless prototypes.

ATmega328P DIP package illustration

ATmega328P

8-bit AVR · 32 KB flash

Where the constraints teach you the most. 2 KB of SRAM makes every buffer, every interrupt and every byte of the vector table a deliberate decision.

C / SoC + FPGA

Programmable logic with a CPU attached

Hard processor system on one side, fabric on the other, and a bus between them. Linux or bare-metal on the PS, custom AXI logic in the PL, and a boot flow that has to bring up both.

Xilinx Kria K26 system-on-module illustration

Xilinx Kria K26 SOM

Zynq UltraScale+ MPSoC

My current target. Cortex-A53 APU and Cortex-R5F RPU firmware, a four-image MT25Q flash layout with sector locking, and AXI logic parsing GNSS and IMU streams.

Terasic DE1-SoC board illustration

Terasic DE1-SoC

Cyclone V · FPGA + HPS

Where the fabric first made sense. Memory controllers and SPI, I2C and CAN cores built in Quartus around a Motorola 68000 soft system.

D / Edge AI

Inference at the sensor

When the model has to run where the data is born — no round trip to a datacentre, a fixed power budget, and a GPU sharing memory with the CPU.

NVIDIA Jetson Nano board illustration

NVIDIA Jetson Nano

Tegra X1 · 128-core Maxwell

A CUDA-capable Linux board on the L4T stack. Camera and sensor pipelines feeding on-device inference, with the same BSP discipline as any other embedded target.

( Experience )

Three teams, one job description: make it boot.

May 2026 — Present Hanoi, Vietnam

Embedded Software Engineer · FPGA

Viettel Aerospace Institute

  • Firmware for the Cortex-A53 and Cortex-R5F processing system on a Xilinx Zynq UltraScale+ MPSoC (Kria K26 SOM), integrated with custom FPGA programmable logic.
  • Designed a generic SPI flash driver for MT25Q NOR flash — read, write, erase and program, plus password-protected sector locking to secure individual partitions.
  • Implemented a four-image flash partitioning scheme: main, backup, an application loader that updates main over USB, and a recovery image that restores the loader over Ethernet.
  • Redesigned the image selector to boot the correct image from a boot-status register, and the FSBL to update a fallback register on a failed update so the board recovers to a known-good image on its own.
  • Built a secure boot flow verifying firmware integrity and authenticity with SHA hashing and CSA keys programmed into eFuse.
  • Wrote AXI programmable logic that parses UART GNSS and IMU streams and forwards encoded messages to processing-system modules through a queue-based architecture; ported and tested sensor fusion and control algorithms from MATLAB into embedded C.
Zynq UltraScale+Kria K26Vitis VivadoAXIMT25QSecure boot
Jan 2026 — Apr 2026 Ho Chi Minh City, Vietnam

Embedded Software Engineer · Bare-metal C

Ban Vien Corporation — Renesas Design Vietnam

  • Wrote C bring-up code for SCP power and clock domains on Renesas R-Car X5H and X5L, debugging SCMI transactions through SCP and kernel logs, and built binary scripts for new chipset integration.
  • Built a Gentable-based automation tool that manipulates register names and values in Excel to the hardware team's specification.
  • Set up TFTP and NFS boot environments for Linux bring-up, and wrote Tera Term macros automating SCP firmware boot and device testing.
  • Developed structured onboarding material for embedded Linux: U-Boot, TF-A, kernel drivers, RootFS, Yocto, Bash and Docker.
R-CarSCPSCMI Bare-metal CTFTP / NFSYocto
Feb 2025 — Jan 2026 Hanoi, Vietnam

Embedded Software Engineer · BSP

FPT Software — Konica Minolta Solution Lab Vietnam

  • Developed and optimised firmware for next-generation multifunction printers on Cortex-A72 (Linux) and Cortex-R4 (FreeRTOS): ATF, U-Boot, kernel drivers, and memory hardware including QSPI flash, RAM and SD/SSD.
  • Enabled RAM upgrades across 6 printer models by modifying U-Boot limits and hardware-check mechanisms, repartitioning memory in the kernel CMEM driver, and updating application startup initialisation.
  • Improved LPDDR4 boot reliability by reimplementing the DDR training sequence in TF-A with retry mechanisms and persistent storage of training results for U-Boot to retrieve.
  • Fixed RAM-to-SD/SSD hibernation snapshot write failures by introducing a new compression mode and multi-core retry mechanisms.
  • Contributed a U-Boot command for erasing QSPI user-data regions, and Secure Boot work validating U-Boot firmware integrity before rewriting verified firmware into the Golden zone.
  • Automated one-click configuration and build of U-Boot, kernel, RootFS and TF-A across 11 printer models in Bash, with optional Secure Boot hashing, and documented DRAM initialisation, hibernation and SecureChip integration for the team.
TF-AU-BootLinux kernel FreeRTOSLPDDR4QSPISecure boot

( Education )

Where the fundamentals came from.

Aug 2020 — Nov 2025 Vancouver, BC, Canada

BASc, Electrical Engineering

University of British Columbia

Relevant coursework

Circuit Analysis I & IIData Structures & Algorithms Computer ArchitectureDigital Design Microcomputer System DesignIntroduction to VLSI CMOS Integrated Circuits

( Projects )

Things built end to end.

UBC · Aug 2023 — Apr 2024

Forest LiDAR Scanner

  • Collaborated on the design and build of a LiDAR scanner that maps trees and generates 3D point-cloud models of forest plots.
  • Integrated vendor IMU C libraries through Python bindings and implemented GNSS processing with Kalman filtering, reaching roughly 4-metre positioning accuracy.
  • Wrote the Python control software for device management, sensor data handling, and a PyQt touchscreen interface.
  • Managed budget, procurement and component selection, delivering at about 80% of the cost of comparable commercial systems.
PythonPyQtKalman filter GNSS / IMUPoint cloud

UBC · Jan 2024 — Apr 2024

Microcomputer System Design

  • Designed ROM and DRAM subsystems using Quartus IP, including memory controllers and interfaces for the Motorola 68000 CPU.
  • Implemented SPI, I2C and CAN controller cores to connect the FPGA platform to external peripherals.
  • Verified hardware and software integration by writing and running embedded C applications on the platform.
VerilogQuartus68000 SPI / I2C / CANMemory controllers

( Toolbox )

The everyday set.

Languages

  • C
  • C++
  • Python
  • Verilog
  • VHDL
  • Assembly
  • Bash

Firmware & OS

  • U-Boot
  • TF-A / ATF
  • FSBL
  • Linux kernel
  • FreeRTOS
  • Yocto
  • Buildroot

Tools

  • Vivado
  • Vitis
  • Quartus
  • Git
  • Jenkins
  • Jira
  • CMake / Make

Spoken

  • English — professional
  • Vietnamese — native