At the 2013 Linux
Plumbers Conference in New Orleans, Rob Clark presented an update
of the progress toward free software graphic drivers on ARM systems.
Free drivers for desktop display hardware are more actively developed,
with many users simply resigning themselves to the
use of binary-only drivers in the ARM system-on-chip (SoC) world. But
as Clark explained, the effort to provide free drivers has gained
significant momentum in the past year alone.
A few years ago, Clark said, the situation looked very bleak, and
there were no projects attempting to write free drivers for ARM SoCs.
Then Luc Verhaegen started his Lima project, an attempt to reverse
engineer the Mali GPU.
That project "motivated the rest of us," Clark said, and now there are
four active projects, each targeting a different GPU.
The first that Clark described is the Etnaviv project for GPUs
made by Vivante. The Vivante GPUs are on the low-end, usually found in
mobile phones and other small devices like the nettop-class CuBox PC.
These GPUs have a fairly straightforward design that is similar to
many desktop GPUs. They use a unified
shader architecture, meaning that there are not separate shader units
designated for separate purposes (e.g., vertex shaders, pixel shaders,
and geometry shaders). Most Vivante models have supported OpenGL ES
2.0, while the latest revision has moved to OpenGL ES 3.0 and OpenCL. The
instruction set is all vector-based, and historically offered only
floating-point data—although here, too, there is a recent
change: the newest models now offer integer support, too.
Etnaviv is making very rapid progress, Clark said: work only
started in late 2012. As of now,
the project has produced a working Gallium3D driver, which is capable
of playing some games. But it only supports the Linux framebuffer (fbdev) backend. The
X backend needs a lot of help, he said: Direct Rendering Manager
(DRM), Direct Rendering Infrastructure (DRI), and 2D X (DDX) support
are all missing.
For NVIDIA's Tegra SoC series, there is the Grate project. Tegra
is a widely-adopted SoC that can be found in a number of well-known
products, such as Samsung Galaxy tablets, the (first-generation) Google Nexus 7, and
Trim-Slice nettops. The GPU architecture is more sophisticated than
Vivante's, with separate vertex and fragment shaders. The instruction
set is "minimalist," Clark said, not even providing loops, but the
GPUs tend to offer good performance by incorporating a massive number
of cores. The devices support OpenGL ES 2.0.
Grate is still in the very early stages, he said, and is not yet
usable. Grate can capture and replay a command stream, the basic GL
state is well understood, and the project has reverse engineered the
vertex shader instruction set architecture. But the vertex shader is
straightforward; the challenge is the fragment shader, which "is
more weird," he said. It uses three separate instruction streams: one
for texture lookup, one for varying
variable interpolation and the "Special Function Unit" or SFU
(which implements out-of-the-ordinary functions like reciprocal square
roots), and one for the standard arithmetic logic unit (ALU). But
even the ALU is unusual; it accepts packets of three to four
instructions and offers just four opcodes.
Clark next discussed the Lima project, which was the first such ARM
GPU driver project to get started. Most of the Lima effort is
directed at the Mali 200 and 400 series, although work has recently
started on the Mali 600 series. The 200 and 400 are similar: both
support OpenGL ES 2.0 and offer separate vertex and fragment shaders,
and both support 2D and cubemap textures. The 600 series diverges
considerably: it supports OpenGL ES 3.0 and OpenCL 1.1, uses a unified
shader architecture (with different models using varying numbers of
cores and ALUs of varying register widths), and supports 3D textures
in addition to 2D and cubemap textures. Mali 200/400 chips are found in
high-end phones, Allwinner devices, and some Samsung tablets, while
the Mali 600 series is found in Google's Chromebooks and Nexus 10 tablet.
The 200/400 series vertex shader is a bit unusual, he said. It is
single-threaded but deeply pipelined. It uses very long instruction
words (VLIW), each of which can include two additions, two
multiplications, one complex ALU operation, one pass-through ALU
operation, one attribute load, one register load, one uniform load,
and one varying store. In addition, there are no explicit output
registers: the outputs from previous instructions are routed into the
current instruction, a job which the shader compiler is responsible for
sequencing correctly. The fragment shader is not quite as strange, he
said, although it uses variable-length VLIW rather than the
fixed-length VLIW design of the vertex shader.
As of now, the Lima driver is starting to reach usable status on
Mali 200 and 400 series GPUs. There is a Mesa-based DRI driver that
runs es2gears (the OpenGL ES version of the famous "glxgears" demo) as well as some
other 3D demos. Connor Abbott has been developing a shader compiler,
although it has not been hooked up to Lima yet. For the Mali 600
series, work has only recently begun, and so there is little progress
Clark himself is the developer behind Freedreno, the driver project
for Adreno GPUs. Adreno GPUs are found in Qualcomm Snapdragon SoCs,
HP TouchPads, and several high-end Android phones. The GPU is
available in two generations. The 200 series chips support
OpenGL ES 2.0, while the 300 series chips support OpenGL ES 3.0 and
Open CL 1.1. Both use a unified shader architecture, although there
are differences between them. The 200 series uses VLIW instructions
on vectors with the ability to co-dispatch scalars, while the 300
series uses explicitly pipelined scalar instructions.
As of now, the Freedreno driver is the furthest along of the free
driver projects. There is an initial DRM/KMS driver in for kernel
3.12, and there is a working Gallium3D driver that supports
both 200 and 300 series GPUs. The Gallium3D driver also works on the
Kernel Graphics Support Layer (KGSL)/fbdev backend for Android. There is an X driver, too, which
can utilize Adreno Z180 2D vector graphics cores. Freedreno currently
implements support for OpenGL ES 1.0 and 2.0 and offers OpenGL 1.4
support on what Clark called "a best effort basis." That best effort
is good enough to run GNOME Shell, XBMC, and several well-known 3D
games like Xonotic and OpenArena. The DRM/KMS backend also supports
the Weston compositor for Wayland.
Binary graphics drivers are a thorny issue: many free software
supporters decry them, but they are a common sight—particularly
on mobile Linux devices. Considering the rapid progress that has been
made on free drivers for desktop GPUs in recent years, it can be easy
to forget just how recently binary drivers were considered a necessary
evil for that hardware as well. As Clark's talk illustrated, free
drivers for ARM SoC systems still have a ways to go, but they are also
making rapid progress, which should give hope to those who feel stuck
with proprietary GPUs in their pockets.
to post comments)