Decrypting device trees for the Pixel 10 under the mainline Linux kernel
The recent launch of Device Trees for the Pixel 10 by Google opens a new era for starting these devices under the Linux kernel main. This announcement follows the presentation of the Pixel 10, Pixel 10 Pro and Pixel 10 Pro XL smartphones, all equipped with the powerful Google Tensor G5 SoC, built around a multi-core ARM Cortex X4, A725 and A520 architecture and equipped with a powerful Imagination DXT-48-1536 graphics unit.
But what role precisely do these device trees play in the context of startup of an embedded Linux system? Essentially, they allow the Linux kernel to properly identify and configure the Pixel 10’s hardware, adapting drivers and initializing necessary components early in the power-on process. They therefore replace the traditional monolithic method known as monolith by a modular and declarative description of the hardware.
To put it simply, a device tree is a file coded in DTS (Device Tree Source) language which declares the hardware topology of the terminal: processors, buses, controllers, integrated peripherals, GPIO, clock, etc. When the Linux kernel starts, it reads this file and adapts its behavior accordingly. This method ensures better modularity and facilitates code maintenance, especially since the Pixel 10 benefits from a complex hardware architecture.
The release of these files for the Pixel 10 is strategic because it foreshadows a wider adoption of the main Linux kernel in the smartphone world, traditionally dominated by Android with its own modified kernel. The ability to boot these devices with the upstream kernel opens the door to the development of alternative ROMs and innovative uses running on a more open and universal software platform.
- Role of Device Trees: Identify and configure the hardware at boot time.
- Pixel 10 Architecture: Tensor G5 SoC with ARM cores and Imagination GPU.
- Google’s Priority: Support booting with the main Linux kernel.
- Impact: Facilitates mobile Linux development and custom ROMs.
- Challenges: Adapting to the Pixel 10’s hardware specifics via DTS.
The Technical Implications of the Mainline Linux Kernel in Pixel 10 Smartphones Integrating the mainline Linux kernel—also known as the upstream kernel—at startup on the Pixel 10 brings several important innovations to the world of mobile embedded systems. First, the official kernel incorporates the majority of fixes and enhancements validated by the Linux community, ensuring optimal stability and better long-term hardware compatibility. Historically, Android has often used customized versions of the kernel, incorporating proprietary or manufacturer-specific patches (Google is one example). This proliferation of variants complicates code maintenance and limits the ability of independent developers to interact effectively with the hardware. The integration of device trees into the mainline Linux kernel for the Pixel 10 thus offers major benefits:
Improved compatibility:
A single kernel for multiple models, reducing code duplication.
- Easier updates: Updates are faster and more secure via the official Linux channel.
- Openness to alternative ROMs: Less dependence on proprietary bootloaders and closed blobs.
- Improved drivers: Community contributions benefit all users.
- However, this evolution still faces some obstacles. In particular, these patches are still very preliminary and require a bootloader not yet released by Google to launch the @mainline kernel, mentioned in discussions on the LKML (Linux Kernel Mailing List). This boot process is currently limited to a simple UART prompt from an initramfs, an initial step that does not guarantee a fully functional system but opens a promising path. Porting to a fully operational system therefore remains a work in progress, but the approach demonstrates the power and flexibility of open-source software to support modern mobile technology. This approach is part of a desire to harmonize the foundations between Android and the main Linux distribution for a more transparent and cooperative future.
Current challenges: Unreleased bootloader, limited functionality. Prospects:
- Running a full upstream kernel on the Pixel 10. Long-term benefits:
- Extended support for architectures and devices. Linux community:
- Strong involvement in driver development for Tensor G5. The role of the bootloader and the constraints associated with booting Linux on the Pixel 10
- Booting a Linux system on a smartphone like the Pixel 10 presents specific technical challenges that go beyond simply defining device trees. One of the key components of this process is the bootloader, a very low-level software responsible for initializing the hardware and launching the Linux kernel. Currently, the bootloader needed to utilize device trees and enable the main Linux kernel to boot is not yet publicly available, which represents a significant bottleneck. This bootloader must, in particular:
Properly load the Linux kernel and initramfs.
Configure hardware and security protections. Initialize essential peripheral interfaces (UART, USB, etc.).Facilitate low-level access via a terminal (UART prompt) for debugging.
This step is crucial because an efficient bootloader unlocks the full potential of the hardware, ensuring that the kernel can boot without errors and interact with all components at power-on time. For example, it must configure the memory controllers and the system clock, operations highly specific to the Google Tensor G5 SoC used in the Pixel 10 series.
- In the case of the Pixel 10, even though the device trees are already available, they can only function fully with this as-yet-undistributed bootloader. This bootloader manages the transition from the initial firmware to the Linux kernel, before the operating system can fully manage the smartphone.
- It is important to note that this approach is similar to that of projects such as
- Asahi Linux ported to Apple Silicon
- , where working on a specific bootloader is just as critical for a smooth boot process compatible with the main Linux kernel.
Key functions of the bootloader:
boot, debugging, hardware initialization.
Current limitation: proprietary, non-open bootloader.Similar example:
- development of Asahi Linux on Apple M3. Impact:
- delay in the full use of the main kernel.
- Discover how Google publishes peripheral trees for the Pixel 10 under Linux, thus facilitating the development and compatibility of hardware drivers. Challenges and Prospects of Mainline Linux Support for High-End Mobile Devices
- The porting of mainline Linux to mobile devices, such as the Pixel 10, represents a major turning point in the convergence of mobile and desktop ecosystems. For several years, kernel fragmentation between Android and standard Linux has hindered the widespread adoption of GNU/Linux distributions on smartphones. But with Google offering suitable device trees, this bridge is beginning to be built.
Software consistency:
a single base for updates and maintenance.
Openness:
- simplified access to open-source software and customization. Security:
- application of best practices from the official kernel and European security patches. Community: a collaborative dynamic ensuring continuous improvement of hardware support. This evolution coincides with the emergence of minimalist tools and distributions, designed to adapt to the specific constraints of a mobile device, following the principles explained in resources such as
- minimalist Linux distribution . Ultimately, this opens the door to credible alternatives to Android, offering a secure, flexible system without reliance on closed components.
- Furthermore, these developments directly influence the design of lightweight server environments and even advanced embedded systems based on Debian LAMP, demonstrating the versatility of the Linux kernel across all domains, from mobile to more traditional infrastructures.
Expected innovations: Full support for mobile Linux systems.Implications for free software:
Towards fewer proprietary dependencies.
- Wider adoption: Impact on Raspberry Pi, servers, and laptops.
- Easy integration: Facilitates secure remote connections on mobile devices.
- How to practically leverage the Pixel 10’s device trees for Linux development For Linux developers and enthusiasts, the release of these device trees offers a golden opportunity to explore and customize the Pixel 10’s boot process via the main kernel. This is a first technical milestone, allowing you to modify, test, and improve hardware compatibility at each stage of the boot process.
- Here are some concrete steps for those who want to venture into this development: Download the patches: Available in the LKML discussion thread, they contain the appropriate DTS files.
Analyze the structure:
Understand the nodes and properties of the trees, and how they correspond to the hardware. Configure the kernel: Integrate the Device Trees into the kernel compilation.
Prepare the initramfs:
- A minimal environment necessary to boot the kernel, facilitating initial testing. Testing the boot process: Using a suitable bootloader, launch the main Linux kernel on the Pixel 10 until a UART prompt appears.
- For further exploration, numerous online tutorials explain how to
- customize and optimize the Linux boot process
- and how to use the essential commands to interact with the system. This includes using advanced methods for debugging, managing kernel modules, and diagnosing boot errors.
- This expertise is invaluable, especially for building custom ROMs or developing Linux-based embedded systems, where every microsecond of performance and every bit of memory usage counts.
Key steps: patching, compiling, initramfs, bootloader.
Recommended tools:
- cross-compilation tools, LKML, Linux environment.
- Resources: Device Tree documentation, tutorials on
- managing suspended tasks. Benefits:deep understanding of the hardware and the boot process.
- Google publishes peripheral trees for the Pixel 10 under Linux, thus facilitating the development and compatibility of hardware drivers.
