First of all... what is it? To keep it simple, it is a multi-layered system that manages rendering and display output.
In this post, we'll explore the Linux graphics stack, focusing on key components involved in integrating DRM driver support into LVGL.
Overview
The following diagram shows all the core elements/libraries to display something on a screen from an application.
There are many libraries and concepts involved to get something displayed on the screen. Let's dive into all these elements!
Some context
There are several other ways to display graphics on a Linux system:
Framebuffer (uses /fbev/fb0). Simple, works on almost any hardware, but has no hardware acceleration and is outdated.
Wayland. Window manager and compositor (can use DRM).
SDL (Simple DirectMedia Layer). Handles graphics, input and audio.
DRM/GBM/OpenGL. Go to the next sections for details!
What is the DRM (Direct Rendering Manager)
The DRM is a Linux kernel subsystem that manages graphics hardware. It provides a unified interface for handling GPU acceleration, framebuffer management, and display output. It ensures efficient rendering while allowing user-space applications to communicate with the graphic hardware.
DRM uses KMS to configure the display settings and set the framebuffer, connectors, and display pipelines to drive the actual screen output.
So... about GBM?
GBM (Generic Buffer Management) is a Linux API that allows applications to allocate GPU buffers without relying on a windowing system like X11 or Wayland. It is primarily used in DRM/KMS-based rendering pipelines to manage graphics memory efficiently.
Ok, and EGL/OpenGL?
OpenGL is the rendering API. It is a cross-platform API used for rendering 2D and 3D graphics. It provides a set of functions that let applications send drawing commands to the GPU. Great! But how?
EGL! is an interface that connects OpenGL with the native windowing system or display hardware (KMS/GBM). EGL creates the graphic context in within OpenGL can render. You can see EGL as the glue between GBM buffers and OpenGL rendering.
OpenGL ES
The name itself gives a hint: Embedded System. It's a lightweight and optimized version of OpenGL that is designed for mobile and embedded devices.
GPU drivers
We will not cover anything about the drivers here, we assume the drivers exist and can be used with the GPU of the system.
Details about the interactions
To make it simple:
DRM library is used to handle the display settings
GBM is used to create the buffers.
EGL uses GBM buffers to create EGL context, creating EGL buffers from GBM.
OpenGL ES uses EGL context to render elements into EGL buffers.
Instead of OpenGL ES, it's possible to use OpenGL or Vulkan. EGL creates a graphic context that can be used by any rendering framework.
DRM in LVGL
LVGL had a DRM implementation using "dumb buffers" to display a buffer on the screen. They are designed to be easy to use but lack GPU acceleration, making them inefficient for advanced rendering tasks. It means it relies on CPU software rendering, being very similar to framebuffer (fbdev).
Why do dumb buffer exist?
Well, they are usually used for debugging and testing low-level DRM/KMS functionality. They are also used as a fallback mode when no GPU acceleration is available. But our objective here is to use the GPU to be more efficient, so we modified the existing DRM support to use:
GBM as buffer allocator
EGL to provide a graphic context
OpenGL ES to render in the context
This feature is coming soon! LVGL v9.3 will have the DRM support using hardware acceleration! Stay tuned ;)