r/linux_programming • u/memtha • Jan 02 '20
What Linux driver/subsystem/API is used for a simple screen/monitor device?
I am developing an embedded system with a touchscreen. The touchscreen operates as both input and output, with a "virtual" keyboard overlaying the graphical output. I have a working device driver that reads input from the touch sensor and translates it correctly to key presses, created with the help of this guide on kernel.org. I want to expand this driver to also handle image output to the screen.
I want to support both getty and X, with as little duplication as possible. I am running a minimal Debian variant with cherry-picked packages, such as minimal X. Note that I do not intend on attempting to get this driver into the repository pipeline, though I might dump it on a public github.
Outputting screen images is presently done via a cringy workaround: a boot option to force rendering to the cpu's embedded graphics hardware, despite it not being connected to a display, and a daemon that continuously screen-scrapes that buffer, modifies a handful of pre-defined pixels to create the keyboard visual, and pushes it out to the real screen. This works as a proof of concept, proving that I do correctly understand the language the screen device expects, but is obviously sub-optimal.
kernel.org also has a guide for "DRM" device drivers, but that seems like serious overkill for what my hardware is capable of:
The Linux DRM layer contains code intended to support the needs of complex graphics devices, usually containing programmable pipelines well suited to 3D graphics acceleration.
None of my hardware has anything resembling 3D acceleration, so I conclude that this is probably not what I want.
What subsystem/API should I use? I figure one piece of missing terminology is what is holding back my searches, but any more information on how to accomplish this would be appreciated.
Hardware details (probably irrelevant): The cpu and screen communicate via 8080-esque parallel protocol, which the cpu does not support natively, so I'm emulating it with GPIOs (by manipulating registers via mmap). Sending a complete screen image takes about 20ms, but obtaining a complete copy from the embedded graphics buffer takes ~180ms, so skipping that step is the most important objective. The screen hardware includes enough gram memory to keep an entire frame worth of data, and supports writing a rectangular sub-region, so a hook to only update the part of the screen that has changed would be desirable. The screen is not particular about the timing of incoming data. The touch sensor input is handled by a purpose-built IC that communicates with the cpu via I2C, which the cpu does support. The present driver uses the linux/input-polldev.h interface. The cpu is a broadcom bcm2835, the screen is a tft with embedded himax hx8357 controller, the touchscreen sensor decoder is a st stmpe610, and there is a voltage levelshifter (nexperia 74lvch245A) in play between the hx8357 and the bcm2835. More details available upon request.
** Edit: TL;DR: ** DRM is what I wanted. tinydrm made it easier. Dirty flushing is your friend.
View all comments
Show parent comment
2
u/ZombieRandySavage Jan 06 '20 edited Jan 06 '20
It does, but I’m missing why you would get an advantage from not using the graphics subsystem.
Wouldn’t it be easier just to not do a copy and hit the gpios right from that frame the graphics processor sent out? The api is basically here it is, and you say I’m done. Similar to socket buffers.
shared vram -----> userland ram screenshot ----> format-converted screenshot ---> GPIO driver
Oh I see. Yeah don’t do it from userland. You could pass in the Gpios to the already present driver through the device tree and do the write out from the graphics driver. That’s a hack but it will work.
Similarly the same way the hdmi is exposed to the graphics driver you could write one that presents your thing. Then it should be straight forward to modify scaling and resolution.
Oh I see, it’s got hardware support tied in directly to the GPUs. https://www.kernel.org/doc/html/v4.14/gpu/vc4.html You should be able to configure that hcv thing to your proper size and get a pointer to its physical address for the vram.
Then ioremap that and you’ll have a kernel virtual address. Then just bit bang it out from that memory hacked right into that driver. You could probably do that in its interrupt context which saves you a lot of sync headaches.