Hacker News Reader

Comment by supersnark | Hacker News Reader

>More AMDGPU DRM driver

DRM is a really unfortunate acronym here. It took me a while to figure out it refers to direct rendering manager.

On a related note, I have a hard time understanding the layout of the Linux graphics stack as a whole. You have MESA, DRM, DAL, Gallium3D, etc... All these acronyms and systems that somehow relate to eachother.

It seems like there are many layers, and there aren't many good references that really explain it "from the beginning".

The wikipedia page at https://en.wikipedia.org/wiki/Free_and_open-source_graphics_... has some somewhat helpful graphics at least explaining the relative abstraction levels of the different entities.

Here's a good writeup from a few years ago about the Linux graphics stack internals:

http://blog.mecheye.net/2012/06/the-linux-graphics-stack/

The collective name is DRI (Direct Rendering Infrastructure), perhaps this Wikipedia page will help?

https://en.wikipedia.org/wiki/Direct_Rendering_Infrastructur...

I think the basic way to understand it all is that the decision was made to pull more of the graphics stack into the Linux kernel, and this has enabled thinner abstractions to be built on top for various purposes. For example, Wayland makes use of the underlying DRI infrastructure.

I've been wondering how Wayland actually works underneath. Seeing how Wayland window managers usually have a drawing layer that among others have a specific backend for Intel, I scratched my head wondering if people have to reinvent/reimplement parts of what xf86-video-intel provides in Xorg. Any insight?

I'm not an expert, but here's how I see it...

There are different ways to create GPU drivers for Linux. In order to make use of DRI, the GPU has to have a DRM driver. This DRM driver is specific to the GPU hardware.

The DRM is the interface that software can work with to make calls to the GPU. You could think of DRM as a way to have a standard interface for GPU calls, so other software will speak to this DRM layer, but the DRM driver will speak to the hardware, which is why the DRM driver needs to be device specific.

The DRM driver is the part of the GPU driver that sits in the kernel, there will also be a userland part of the GPU driver. I believe the part of the driver that gets used will depend on what the software is targetting. Wayland will target the kernel side, but games would work with the userland side.

These images from Wikipedia may help visualise what DRM is doing. Without DRM: https://en.wikipedia.org/wiki/Direct_Rendering_Manager#/medi...

With DRM: https://en.wikipedia.org/wiki/Direct_Rendering_Manager#/medi...

As a side note, it's possible for GPU vendors to create more generic GPU drivers by using Gallium3D. This also creates drivers that work with DRI, but GPU drivers don't need to use Gallium3D to use DRI. I would suggest thinking of Gallium3D as a set of reusable GPU driver components, you could code a driver using these reusable components, or you could code something bespoke.

https://en.wikipedia.org/wiki/Gallium3D

In terms of Wayland in particular, you may be interested in this:

https://wayland.freedesktop.org/architecture.html

Does this help?

Yes, the picture kinda confirms my suspicion. Looking at this https://github.com/michaelforney/wld/blob/master/intel/i965_... you have to wonder how much device-specific stuff one has to implement now when targeting Wayland and if that's avoidable or why libwayland doesn't have libwayland-intel etc?

By the looks of that header file, the i965 driver covers multiple different devices, I'm guessing it's using those values to enumerate a list of the Intel CPUs that the driver works with.

In terms of Wayland, I would suspect that it isn't necessary to have anything vendor specific, the whole point of targeting an abstraction layer like the DRI is to eliminate the need to cater for differences in devices.

FWIU, drivers don't have to specifically support Wayland. As long as they support Khronos's EGL spec, wayland will run on those drivers.

EGL is sort of a cross-platform spec for window managers to work with graphics cards.

So is it just that the APIs are not there yet which motivated wld to talk directly to Intel's DRM?

I doubt that. libdrm should have been enough, but this was about two years ago, when Wayland wasn't ready. I don't know much about how wld is using libdrm_intel, and I don't think I'll be much the wiser even if I read the code. Maybe ask the author.

Direct Rendering Mode, yes

And before that DRI back when we used to build our own X11 from CVS.

That acronym misled me too: "DRM? In Linux? :("

Reply on news.ycombinator.com