Writing a Linux Driver From Scratch to Watch Free TV on a Raspberry Pi

Scott Steinmetz — Tue, 28 Jul 2026 03:20:31 +0000

May 2026

There's a touchscreen mounted in my kitchen — I call it the WallScreen. It runs recipes, the chore board, a calendar, the usual smart-home clutter. One day I decided it should also pull in free over-the-air television. No subscription, no streaming app, just the local broadcast towers that have been beaming HD into the air for free this whole time. I had a Raspberry Pi 5, a $30 USB tuner, and what I assumed would be a boring afternoon.

It was not a boring afternoon.

The tuner that didn't want to work

The tuner I grabbed was a MyGica A681 — a tidy little USB TV stick. Plug it into Windows, install the bundled software, done. Plug it into a Raspberry Pi running a current Linux kernel and you get… nothing. The computer notices a device is there and otherwise shrugs.

Here's why, in two sentences:

Linux has no built-in driver for the chips inside this particular stick.
The manufacturer's driver only works on regular PC processors — and even then, only as a sealed, prebuilt file with no source code. A Raspberry Pi uses a different kind of chip entirely, so that driver is a non-starter.

That's the whole problem. The hardware is great. It's just that on a Pi, this tuner is a paperweight — and you can't buy or download your way out of it.

The only way out was to write the driver myself.

What writing the driver actually involved

A USB TV tuner isn't one chip — it's a little team of them working together. One chip is the "translator" that lets the computer talk to the device over USB. Another tunes to a channel, like turning a radio dial. A third converts the broadcast signal into video data the computer can use.

The good news: for the parts that handle tuning and decoding the signal, I was able to build on existing open-source work from the broader Linux TV community — code other people had already written and shared for the chips inside this stick. (It's all credited in the project.)

The missing piece — the part nobody had written — was the translator layer: the code that tells Linux "this device exists, here's how to send it commands, and here's how to pull the live TV stream out of it." That's the driver I built from scratch. Once it was in place, the existing pieces could finally do their jobs, and the signal had a path from the antenna all the way to the screen.

In theory.

The bug that ate the afternoon

When I first loaded everything up, the tuner reported that it had locked onto a real TV station. Every indicator was green. And it produced zero video.

A tuner that's "locked on" but sends no picture is a uniquely maddening problem, because nothing looks broken. I spent hours convinced I had a setting backwards, and tried every variation I could think of to coax data out of it.

The fix, embarrassingly, was to change nothing. The code I'd built on came with a sensible default for how the video data should flow out of the device — and that default was correct all along. The moment I'd "helpfully" switched it to what I assumed was the right mode, I'd broken it. I put the default back and the live TV stream came pouring out.

The lesson I keep relearning in this kind of work: when something already ships with a sensible default, the burden of proof is on changing it — not on second-guessing it.

When the instruments lie

The second trap was sneakier. With video finally flowing, I checked the tuner's own readouts for signal quality — strength, error rate, that sort of thing. They were terrible: numbers that said the signal was practically nonexistent, on a channel that was playing flawlessly right in front of me.

It turned out those particular readouts were never actually implemented for this chip — they just report meaningless noise. If I'd trusted them, I'd have concluded my working driver was broken and thrown it away.

So I stopped trusting the dashboard and started checking the data directly: a tiny script that grabs a few seconds of the live stream and confirms it has the structure a real TV broadcast should have. If it does, the driver works — full stop, no matter what the instruments claim. That capture-and-check became my real source of truth, and it's the method I recommend to anyone using the driver.

The payoff: it locked cleanly onto my local stations and pulled in every channel and subchannel they broadcast.

Making it last

A driver that works today but breaks the next time the Pi updates itself is just a future headache. So I packaged it to rebuild itself automatically whenever the system installs a new version of Linux, and to load the moment the tuner is plugged in. Install it once and forget it's there.

From "it works" to "TV anywhere in the house"

A working driver gives you raw data, not a TV experience. To finish the job I layered the standard open-source TV software on top: a backend that scans the airwaves and organizes everything into proper channels, and a TV-style interface on the WallScreen itself with a one-tap launcher.

The fun part is how many ways the rest of the house can now watch the same antenna:

Straight from a web browser. Any device on my home Wi-Fi can open a page and start watching — no app to install. To keep this smooth, the actual video conversion is offloaded to my ProDesk, a more powerful machine on the network, so the little Pi isn't stuck doing the heavy lifting just to feed a browser.
Through a free TV app. On a phone, laptop, or another TV box, you can install Kodi (a free, open-source media app), point it at the home TV server's address, and get the full channel guide and a proper remote-friendly interface.

There's one honest limitation to call out: I'm using a single tuner. A tuner can only sit on one channel at a time — but it can hand that one channel out to as many screens as I want. So the whole house can watch the same station together with no trouble; what it can't do is let one person watch the news while someone else watches a game on a different channel. That would take a multi-tuner device (something like a multi-tuner network TV box that holds several channels at once). For now, one tuner covers how we actually watch, and stepping up is just a matter of swapping in bigger hardware later — the software already handles it.

A couple of other things this setup can do that I deliberately left for a future upgrade, to keep the first version simple:

Watching from outside the house — secure remote access so I could pull up local channels while traveling.
Recording shows (DVR) — the software supports scheduling recordings like a TiVo.

Both are well within reach with what's already running; I just chose to get live TV rock-solid first and treat those as phase two.

There was also one last gremlin worth a mention: the TV software kept crashing and restarting mid-show, which looked like a flaky signal but turned out to be a single bad default value buried in its streaming settings. One corrected setting and it's been rock-solid since.

The takeaway

What started as "let me plug in a TV tuner" turned into reverse-engineering how the device talks, writing a piece of the operating system by hand, and chasing down two bugs that each disguised themselves as something they weren't. That's the nature of this kind of work: the hardware is rarely the hard part — it's the undocumented gaps between the pieces.

The kitchen screen now plays free local HD on tap — and so does every phone, laptop, and TV in the house. The best part: the next person who buys this same tuner for their Raspberry Pi doesn't have to spend the afternoon I spent.

I've published the complete, working driver on GitHub so anyone can use it:
https://github.com/LordLuktor/mygica-a681-linux-driver

Clone it, run the installer, plug in your tuner, and you're watching TV — no proprietary software, no subscription, no fuss. It's free and open-source, with full credit to the open-source TV community whose work made it possible.

DEV Community: Scott Steinmetz