Building the ZynqMP PMU firmware, the simple way

The PMU firmware

The Zynq UltraScale+ MPSoC, or simply ZynqMP for brevity, is a powerful and complex chip by Xilinx based on ARM cores and an FPGA. Within that chip, the PMU (Platform Management Unit) is a Microblaze processor that handles power states, clock and power domains and other very low-level tasks. It obviously has a crucial role for the chip.

There is no “standard” PMU firmware image: every user is supposed to build a custom one. Luckily its code is open source, and publicly available on the Xilinx Embeddedsw repository.

Building it

Unfortunately building a PMU firmware can be a bit annoying. One of the reasons is that it’s the only programmable Microblaze core in a chip that otherwise has only ARM cores. As such it needs an appropriate toolchain.

One of the solutions is to built it using the Xilinx XSDK, a firmware IDE by Xilinx. But it is a heavyweight tool just to build a 128 kB firmware, and it’s non-trivial to automate in a build process.

The other mainstream option is to let Yocto build it, which is a natural choice if you are using it to build the rest of your system. Some obscure rules are available in the meta-xilinx layer to build a Microblaze toolchain in an otherwise ARM64 configuration, and then use it to build the PMU firmware and its dependencies. This is a powerful method, but it makes it hard to understand how the firmware gets built. It also requires to build a toolchain and several packages at every build from scratch.

Booting with U-Boot SPL

Things get even more complex if you want to boot using U-Boot and its SPL, and here’s why.

To know how the chip resources are to be managed, the PMU firmware needs a “configuration object” to be passed from the outside even before U-Boot proper can start. The Xilinx First Stage Bootloader (FSBL) is able to load the configuration object. But using FSBL has drawbacks, including a poor boot speed.

The obvious alternative is U-Boot SPL, which is fast and the de facto standard in the embedded Linux ecosystem. Except it is currently unable to pass the configuration object to the PMU.

The current best hack to boot with U-Boot SPL is to modify the PMU firmware source code to load a configuration object hard-coded in its own image. This removes the need for the SPL to load it. Implementing this hack requires additional build-time operations, and is implemented for example in the meta-topic Yocto layer. This hack works, although it forces to build a different PMU firmware for every different configuration (e.g. every board), but at the moment there’s not much that can be done. Moreover it adds to the complexity of the build process, since these hacks are not implemented in the meta-xilinx Yocto layer.

Keep it simple, stupid!

Does building a PMU firmware really need to be that complex? Of course not!

So in order to document and simplify the whole process, including the above mentioned hack to boot with U-Boot SPL, I wrote a shell script that does it in the simplest possible way. The design goals for this script are being simple, have minimal dependencies and to be easy to understand and modify.

The resulting script is even simpler than I expected! It also works without the need to setup a Yocto environment or any Xilinx IDE: actually it only needs crosstool-NG to build the Microblaze toolchain and the PMU firmware source code. It also allows to build a toolchain once and reuse it for every build, meaning a different PMU firmware image can be rebuilt in less than 10 seconds.

I published this script on the zynqmp-pmufw-builder GitHub repository. Feel free to use it for your projects, or simply to understand what’s going on when you use other tools!

Embedded Linux Conference Europe 2017

Embedded Linux Conference Europe is the most in-depth technical conference in Europe about Embedded Linux.

For the 2017 edition, taking place in Prague in late October, I will give the talk “How I Survived to a SoC with a Terrible Linux BSP“. It will be a revised edition of the talk I gave last February at FOSDEM 2017.

Among the other talks here are a few ones that caught my attention as particularly interesting:

…and just after that, I’ll be busy for Linux Day 2017 in Bergamo, Italy. I’ll give an introductory talk about “Build Automation with Make, Autotools and CMake”.


FOSDEM LogoFOSDEM is an exciting event where hackers can meet to share ideas and experiences about free and open source software.

With hundreds of talks in the schedule it’s hard to find a topic that is not covered. And with thousands of participants it’s easy to meet people with common interests, including the developers of free software you’re using daily!

This year I’ve been selected to give talk a titled “How I survived to a SoC with a terrible Linux BSP“.

If you’re interested in embedded Linux systems you’ll probably find interesting talks in the rest of the Embedded, mobile and automotive devroom schedule. But also the Architectures main track, the IoT devroom and the Electronic Design Automation devroom should get a bit of your attention.

See you in Brussels!

Linux Day 2016

Saturday, October 22 will be the Linux Day, an event that brings knowledge about Linux and free software throughout all Italy.

BgLUG sets up a great Linux Day in Bergamo since several years.The event program has recently been released, and once again it is packed with interesting topics.

This year I have been selected to talk about:

  • Data processing on the command line: a short workshop that presents some of the many tools available on the command line and how to combine them to analyze and process data;
  • Objected-oriented programming in C in the Linux kernel: a talk that introduces how to build complex, object oriented software using the C language, showing how these techniques are heavily used in the Linux kernel.

See you there!

Embedded Linux Talk

I created a talk titled Embedded Linux – un pinguino piccolo piccolo (“Embedded Linux – a small small penguin”) to explain the basics of embedded Linux systems to a moderately technical audience.

Here’s the abstract:

An embedded system is a computer, but it doesn’t look like. It can have infinite variants: peripherals, memory, shape… The only rule is that there are no rules! Let’s discover how complex a tiny embedded Linux system is. Then let’s discover how simple it can get bringing an ARM board to life using Buildroot.


This talk has been devised for the Linux Day 2015 (see the talk page).

I repeated it in a BgLUG event in March 2016, with an extended live demo, and at the Arduino/Genuino Day 2016, in a shorter form.


You can download the the slides (PDF, italian). The source code is on my GitHub repository.

By continuing to use the site, you agree to the use of cookies. more information

The cookie settings on this website are set to "allow cookies" to give you the best browsing experience possible. If you continue to use this website without changing your cookie settings or you click "Accept" below then you are consenting to this.