Open Source Summit Europe 2025

Linux power management has relied on CPUIdle to transition CPUs into low-power states for a long time. More recently, suspend-to-idle (s2idle) was added which relies heavily on the CPUidle infrastructure to support system-wide suspend & resume using low-power idle states.

On modern Arm SoCs, deeper idle states can shut down not just the CPU, but also local per-CPU timers, interrupt controllers and peripherals, sometimes leading to unexpected entry-exit failures, scheduling delays, and even system hangs.
Debugging such issues can be complex since common debug methods may not be available in low-power modes and because the kernel, platform-specific firmware and dedicated hardware all interact to enable low-power modes. Therefore, debugging requires a good understanding of the CPUIdle internals, PSCI firmware interactions and wakeup timer behavior.

Through real-world case studies, attendees will learn how to trace idle state transitions, identify CPU wakeup failures, ARM Trusted Firmware's PSCI framework internals and apply effective debugging strategies to ensure correct working of the CPUIdle framework on their ARM Linux systems.

With the growing adoption of TPMs (Trusted Platform Modules) in the Linux ecosystem, thanks to features like TPM-backed disk encryption in systemd and the longstanding use in Windows BitLocker, TPM chips are seeing a resurgence as a go-to for secure secret storage. This trend is increasingly making its way into embedded devices. Often as a measure to fulfill NIS2, EU Cyber Resilience Act or similar requirements.

However, embedded systems present a vastly different threat model compared to desktops or servers, and TPMs often don’t deliver the level of security many developers assume. In this talk, David will demystify TPM functionality in embedded Linux environments. He will give a concise overview of security threats for embedded devices and where a TPM can and or where it cannot. Special focus will be put on using TPMs for disk encryption and integrity.

The session will wrap up with a discussion of alternative approaches, other usage scenarios for TPMs, and how to make informed decisions when designing secure embedded systems.

Modern System-on-Chips (SoCs) are designed for a wide range of applications, including mobile devices, automotive systems, AI accelerators, and data servers. As SoCs become more powerful with increasing core counts, heterogeneous architectures, higher clock speeds, and enhanced AI processing capabilities, power consumption also rises. This increased power demand introduces challenges such as heat dissipation, battery life, clock management complexity and system reliability. In this talk, we explore various techniques to optimize power consumption and enhance performance using Common Clock Framework (CCF) in the Linux kernel.

We begin by discussing the role of clock management in Linux and covers various clocking strategies available in CCF to achieve optimal power and performance. Topics include dynamic clock scaling, disabling unused clocks, efficient parent clock selection and the notifier mechanism. We also explore clock usage monitoring in Linux through debugging tools such as clk_summary and kernel tracing.

Overall, this talk demonstrates how effective clocking strategies in the Linux kernel can significantly improve power efficiency and system performance in high-end SoCs.

Memory to Photons: Whether it's a moving picture or a game, Linux's graphics stack is complex, involving various components in both the Kernel and userspace. Getting my first pixel to appear on an LVDS screen was an exciting journey. This talk will walk through my experience of getting started with Linux graphics, based on my recent work on Allwinner A133 display engine support [1] and my ongoing effort to get Imagination Technologies' GPU GE8300 into the upstream kernel.

Ever heard of DRM, GPU, MIPI, Khronos, OpenGL ES, Vulkan, KMS, Weston, HDMI, framebuffer, or Mesa3D, and wondered what all these are? This talk will detail the basic components of the Linux graphics stack and how it's layered. Additionally, it will discuss the specifics of how the Linux kernel's DRM is structured, which parts you’ll be interested in when building your display pipeline, and how to debug when you don't see your pixel.

[1]: 20241227-a133-display-support-v1-0-abad35b3579c@linumiz.com/" target="_blank">https://lore.kernel.org/all/20241227-a133-display-support-v1-0-abad35b3579c@linumiz.com/

Recent Rockchip SoCs (namely, those of the RK35 generation) integrate dedicated IP blocks for video capture and image signal processing. These additions open the door to a wide range of interesting multimedia applications. However, support for these blocks in mainline Linux remains one of the last missing pieces in an otherwise well-supported SoC lineup. It is time to close that gap!

In this talk, I will provide an overview of the software stack for modern multimedia SoCs, cover the contributions that have already landed in mainline and are currently in flight, respectively, and outline the remaining work needed to fully enable video capture and camera functionality. We will also take a look at the compelling applications that this groundwork makes possible.

As a userspace developer, creating graphical applications is a common task. While software and frameworks like Weston or Qt make it straightforward to display content on a screen, ensuring compatibility across various displays poses significant challenges. Users may have different screen sizes, resolutions, and capabilities, making comprehensive testing complex. How will your application perform on a small screen? What about an extremely large one? How does it react to displays being connected/disconnected? Moreover, if your application must run on diverse devices, how will it leverage or adapt to varying hardware capabilities?

VKMS addresses these challenges by enabling graphic testing without the need for physical hardware. VKMS is a Linux kernel DRM driver that allows you to emulate a wide range of display configurations on any device. This talk will introduce VKMS, highlight its current capabilities, demonstrate practical test examples, and provide details on additional features we are currently working on upstreaming into VKMS.

When you use OSS, do you want to know which source files are compiled and included in the binaries? Project ESSTRA (https://github.com/sony/esstra) is a tool that collects a list of source files while compiling your software and embeds the data into the binaries.

Recently, the importance of using SBOMs has been increasing, and there is a growing demand for improved transparency and traceability in the software supply chain from the perspectives of vulnerability management and OSS license compliance. However, it is difficult to trace the details of which files are included in the binaries used in your product or service, and which OSS licenses to comply with based on this data.

To solve this issue, Sony has developed ESSTRA. It is available now as open source itself, and includes both a GCC plugin to record source files during a build and embed it into resulting binaries, as well as a tool to manage the information.

ESSTRA is already supported by Binary Analysis Next Generation (BANG) tool.

Attendees of this session will learn how to use ESSTRA and take the first steps to improve the transparency and traceability of your project's software.