In high-reliability embedded systems—where deterministic behavior and fault tolerance are non-negotiable—VxWorks has long been a cornerstone RTOS. Used in spacecraft, avionics, and defense systems, it combines real-time performance with industrial-grade robustness.
This article explores the adaptation of VxWorks 7.0 to the NXP (Freescale) T2080 processor, based on a research implementation targeting airborne radar systems. It walks through the full porting workflow, from bootloader selection to kernel configuration, device tree integration, and custom driver development.
🚀 Why VxWorks 7.0 and the T2080? #
VxWorks has a long history in mission-critical environments such as the Mars Pathfinder, Patriot missile systems, and fighter aircraft. With VxWorks 7, Wind River introduced a modular, componentized architecture that separates the core kernel from services like networking and file systems. This design improves scalability, maintainability, and support for modern 64-bit PowerPC platforms.
The T2080 processor belongs to NXP’s QorIQ family and is designed for compute-intensive embedded workloads:
- Quad-core PowerPC architecture with SMT (8 threads)
- Integrated AltiVec vector engine
- Up to 172 GFLOPS of vector performance
- Optimized for radar, networking, industrial control, and defense systems
In the referenced research, the T2080 is used as the foundation for a universal processing card in airborne radar units. The primary objective of the adaptation was to achieve predictable real-time behavior while fully exploiting the processor’s parallel and vector-processing capabilities.
🧰 Bootloader Development with U-Boot #
A robust bootloader is essential for any RTOS port. For VxWorks 7, Wind River recommends U-Boot, replacing the legacy Bootrom approach used in VxWorks 6.x.
U-Boot offers several advantages:
- Rich hardware debug commands
- Flexible boot media support
- Easier board-level customization
- Strong community and vendor backing
Development Environment #
The adaptation was performed using:
- Ubuntu 14.04 running on VMware
- Cross-compilation tools from the NXP Yocto SDK
- U-Boot source tailored for QorIQ platforms
Key source directories included:
arch/powerpc/mpc85xxfor processor startup codeboard/freescale/t208xrdbas the reference board template
Boot Flow on the T2080 #
The T2080 supports multiple boot sources, including IFC NOR Flash, SPI Flash, and eMMC.
-
NOR Flash boot
- Stage 1: Assembly code initializes basic hardware and DDR, then copies U-Boot to RAM
- Stage 2: C code configures MMU, peripherals, networking, and loads the kernel
-
SPI Flash / eMMC boot
- Uses U-Boot SPL, which runs from internal SRAM
- SPL initializes DDR and loads the full U-Boot image into RAM
Board Transplantation #
Porting U-Boot required:
- Creating a custom board directory (e.g.,
t208xleihua) - Modifying configuration headers and device parameters
- Adding board-specific
defconfigentries
The final image was built using standard U-Boot build commands, producing a tailored bootloader capable of reliably launching VxWorks 7 on the custom T2080 hardware.
⚙️ Kernel Adaptation in VxWorks 7 #
Once U-Boot was operational, attention shifted to adapting the VxWorks kernel using Wind River Workbench 4.0.
VxWorks 7 introduces several architectural changes:
- BSP logic is reorganized into the Platform Support Library (PSL)
- Drivers follow the VxBus GEN2 model
- Kernel services are built and configured through modular projects
VSB and VIP Projects #
The workflow involves two primary project types:
-
VSB (VxWorks Source Build)
Compiles core libraries and system components -
VIP (VxWorks Image Project)
Builds the final bootable kernel image
Developers select required kernel components—such as networking, file systems, or debugging features—through the Kernel Configuration interface, then build the final image for deployment.
🌳 Device Tree Integration #
A major improvement in VxWorks 7 is its adoption of the Device Tree (DT) mechanism, inspired by Linux.
Previously, hardware details were embedded directly in BSP or driver code, requiring recompilation for any hardware change. Device Tree decouples hardware description from software logic.
Key characteristics:
- Hardware is described in a human-readable DTS file
- DTS is compiled into a binary DTB
- U-Boot passes the DTB to the kernel at boot time
- The kernel dynamically binds drivers to devices based on DT entries
For the T2080 board, the DTS file resides in the BSP directory and defines CPUs, memory regions, interrupts, buses, and peripherals. Tools such as vxrtdtbdump are used to inspect and validate the DTB during debugging.
🔌 Custom Driver Development #
Although VxWorks provides many standard drivers, certain T2080-specific peripherals—such as SRIO interfaces—required custom implementation.
Driver development followed these principles:
- Use DKM (Downloadable Kernel Module) projects
- Conform to VxBus GEN2 driver architecture
- Define hardware resources via Device Tree nodes
In the SRIO case, multiple physical ports were modeled as a single logical device with shared registers. Driver source code was integrated into the VSB for tight coupling with the kernel, allowing performance tuning and bug fixes at the system level.
📌 Key Takeaways #
This adaptation demonstrates a complete and modern workflow for porting VxWorks 7.0 to a high-performance PowerPC platform:
- U-Boot provides a flexible and debuggable boot foundation
- VxWorks 7’s modular architecture simplifies kernel customization
- Device Tree cleanly separates hardware description from software
- VxBus GEN2 enables scalable, reusable driver design
The approach serves as a practical reference for engineers working on PowerPC-based real-time systems, particularly in aerospace, radar, and defense applications where performance and determinism are critical.