Wouter Verhelst: On Free Software, Free Hardware, and the firmware in between

When the Free Software movement started in the 1980s, most of the world
had just made a transition from free university-written software to
non-free, proprietary, company-written software. Because of that, the
initial ethical standpoint of the Free Software foundation was that it’s
fine to run a non-free operating system, as long as all the software you
run on that operating system is free.

Initially this was just the
editor.

But as time went on, and the FSF managed to write more and more parts of
the software stack, their ethical stance moved with the times. This was
a, very reasonable, pragmatic stance: if you don’t accept using a
non-free operating system and there isn’t a free operating system yet,
then obviously you can’t write that free operating system, and the
world won’t move towards a point where free operating systems exist.

In the early 1990s, when
Linus initiated the
Linux kernel, the situation reached the point where the original dream
of a fully free software stack was complete.

Or so it would appear.

Because, in fact, this was not the case. Computers are physical objects,
composed of bits of technology that we refer to as “hardware”, but in
order for these bits of technology to communicate with other bits of
technology in the same computer system, they need to interface with
each other, usually using some form of bus protocol. These bus protocols
can get very complicated, which means that a bit of software is required
in order to make all the bits communicate with each other properly.
Generally, this software is referred to as “firmware”, but don’t let
that name deceive you; it’s really just a bit of low-level software that
is very specific to one piece of hardware. Sometimes it’s written in an
imperative high-level language; sometimes it’s just a set of very simple
initialization vectors. But whatever the case might be, it’s always a
bit of software.

And although we largely had a free system, this bit of low-level
software was not yet free.

Initially, storage was expensive, so computers couldn’t store as much
data as today, and so most of this software was stored in ROM chips on
the exact bits of hardware they were meant for. Due to this fact, it was
easy to deceive yourself that the firmware wasn’t there, because you
never directly interacted with it. We knew it was there; in fact, for
some larger pieces of this type of
software it was possible, even in
those days, to install updates. But that was rarely if ever done at the
time, and it was easily forgotten.

And so, when the free software movement slapped itself on the back and
declared victory when a fully free operating system was available, and
decided that the work of creating a free software environment was
finished, that only keeping it recent was further required, and that we
must reject any further non-free encroachments on our fully free
software stack, the free software movement was deceiving itself.

Because a computing environment can never be fully free if the
low-level pieces of software that form the foundations of that computing
environment are not free. It would have been one thing if the Free
Software Foundation declared it ethical to use non-free low-level
software on a computing environment if free alternatives were not
available. But unfortunately, they did not.

In fact, something very strange happened.

In order for some free software hacker to be able to write a free
replacement for some piece of non-free software, they obviously need to
be able to actually install that theoretical free replacement. This
isn’t just a random thought; in fact it has
happened.

Now, it’s possible to install software on a piece of rewritable storage
such as flash memory inside the hardware and boot the hardware from
that, but if there is a bug in your software — not at all unlikely if
you’re trying to write software for a piece of hardware that you don’t
have documentation for — then it’s not unfathomable that the
replacement piece of software will not work, thereby reducing your
expensive piece of technology to something about as useful as a
paperweight.

Here’s the good part.

In the late 1990s and early 2000s, the bits of technology that made up
computers became so complicated, and the storage and memory available to
computers so much larger and cheaper, that it became economically more
feasible to create a small, tiny, piece of software stored in a ROM chip
on the hardware, with just enough knowledge of the bus protocol to
download the rest from the main computer.

This is awesome for free software. If you now write a replacement for
the non-free software that comes with the hardware, and you make a
mistake, no wobbles! You just remove power from the system, let the DRAM
chips on the hardware component fully drain, return power, and try
again. You might still end up with a brick of useless silicon if some
of the things you sent to your technology make it do things that it was
not designed to do and therefore you burn through some critical bits of
metal or plastic, but the chance of this happening is significantly
lower than the chance of you writing something that impedes the boot
process of the piece of hardware and you are unable to fix it because
the flash is overwritten. There is anecdotal
evidence
that there are free software hackers out there who do so. So, yay,
right? You’d think the Free Software foundation would jump at the
possibility to get more free software? After all, a large part of why we
even have a Free Software Foundation in the first place, was because of
some piece of hardware that was
misbehaving,
so you would think that the foundation’s founders would understand the
need for hardware to be controlled by software that is free.

The strange thing, what has always been strange to me, is that this is
not what happened.

The Free Software Foundation instead decided that non-free software on
ROM or flash chips is fine, but non-free software — the very same
non-free software, mind — that touches the general storage device that
you as a user use, is not. Never mind the fact that the non-free
software is always there, whether it sits on your storage device or not.

Misguidedness aside, if some people decide they would rather not update
the non-free software in their hardware and use the hardware with the
old and potentially buggy version of the non-free software that it came
with, then of course that’s their business.

Unfortunately, it didn’t quite stop there. If it had, I wouldn’t have
written this blog post.

You see, even though the Free Software Foundation was about Software,
they decided that they needed to create a hardware
certification program. And this hardware
certification program ended up embedding the strange concept that if
something is stored in ROM it’s fine, but if something is stored on a
hard drive it’s not. Same hardware, same software, but different
storage. By that logic, Windows respects your freedom as long as the
software is written to ROM. Because this way, the Free Software
Foundation could come to a standstill and pretend they were still living
in the 90s.

An unfortunate result of the “RYF” program is that it means that
companies who otherwise would have been inclined to create hardware that
was truly free, top to bottom, are now more incentivised by the RYF
program to create hardware in which the non-free low-level software
can’t be replaced.

Meanwhile, the rest of the world did not pretend to still be living in
the nineties, and free hardware communities now exist. Because of how
the FSF has marketed themselves out of the world, these communities call
themselves “Open Hardware” communities, rather than “Free Hardware”
ones, but the principle is the same: the designs are there, if you have
the skill you can modify it, but you don’t have to.

In the mean time, the open hardware community has evolved to a point
where even CPUs are designed in
the open, which you can design your own version of.

But not all hardware can be implemented as RISC-V, and so if you want a
full system that builds RISC-V you may still need components of the
system that were originally built for other architectures but that would
work with RISC-V, such as a network card or a GPU. And because the FSF
has done everything in their power to disincentivise people who would
otherwise be well situated to build free versions of the low-level
software required to support your hardware, you may now be in the weird
position where we seem to have somehow skipped a step.

My own suspicion is that the universe is not only queerer than we
suppose, but queerer than we can suppose.

— J.B.S. Haldane

(comments for this post will not pass moderation. Use your own blog!)