on disabling drivers that use non-Free firmware

[Alexandre Oliva]

On Jan  5, 2009, Richard M Stallman <rms at gnu.org> wrote:

>     Hmm...  I don't like the idea of removing Free Software just because, in
>     order to be useful, it pretty much requires someone to run non-Free
>     Software as well.

> Our policy is already to reject such programs, since they
> are "trapped" (the former Java trap was an instance).

Note the 'pretty much'.

Should we have rejected a Free program that ran on one of the Free Java
Virtual Machines whose development I joined back in 1996 or so, just
because most people would run them on a JVM?  I don't think so, and I
don't think this scenario is comparable with that of Linux drivers that,
until someone develops Free firmware, will *only* run in the presence of
non-Free firmware.

So, I do see that, if anything, there's more reason to reject these Free
drivers than there was to reject Java programs back then.  However,
since I don't think we ever rejected Java programs that could run on
Free JVMs just because people might run them on non-Free JVMs, this
doesn't help me see where to draw the line.

> For instance, one of the requirements for listing a program
> in the Free Software Directory is that it work in
> an entirely free system.

Wow, I'm quite surprised stuff such as Cygwin isn't there, although I
can kind of understand why.

>     Say, I don't oppose Gnash, Samba, Wine, or FreeDOS, although their
>     primary use cases are for people who run non-Free Software,

> Those are not similar cases.  None of them _requires_ a
> non-free program in order to run at all.

The drivers don't, either.  They just won't do anything useful.  In a
few cases, they might even do something useful.  I played with replacing
the non-Free firmware files with zero-sized files at some point, while
some devices failed miserably with that arrangement (e.g. sound cards
producing random noise from the moment the firmware was loaded until the
machine was powered off), others seem to have managed to do useful work.


Take Gnash, for one.  I don't disbelieve that there might be Free
Shockwave Flash programs out there, but I don't know of any.  Still,
it's listed as a high-priority project, and the better it works, the
more non-Free Software people will run with it (unawares!), and I don't
envision people out there writing lots of Free Shockwave Flash programs.
I might be mistaken on this, though.  I'm not much of a web person
myself, but some Free Javascript-based stuff I saw lately made me
question the alleged justification for Shockwave Flash.

Take Samba.  Sure, someone might use it to transfer files or share
printers between Free systems, but why would someone do such a thing, if
Free systems have superior file-transfer and printing protocols?  AFAIK
the only reason someone would run Samba is to interoperate with machines
infected with the MS-Windows virus.

Take Wine.  It doesn't make sense unless you can't recompile the program
on a Free system, and if you can't, the program is not Free.  Sure, one
could use Wine to run e.g. Cygwin (I suppose), and if it works, I wonder
why Cygwin wouldn't be listed in the FSD.  But it would still be
pointless.  To me, Wine seems to only make a difference when what one
wants to run is a non-Free Windows program.

As for FreeDOS, it may have been a mistake to list it.  Someone might
want it to run say DJGPP on it, although I'm not quite sure why someone
would want to do that these days.  But that's none of my business :-)

> And none of them leads the user to install any particular non-free
> program.

All of them purport to enable users to *continue* using certain non-Free
programs, regardless of whether they're installed on the same machine, a
neighbor machine, or downloaded from the Internet by a browser.

That's the same reasoning I used to reason about the inclusion of the
drivers that require non-Free firmware in Linux-libre.  I recommend them
to be used in the same scenarios I recommend people to use the programs
above: to keep on using software whose license you've already agreed
with and that you're not ready to stop using yet, in case you've already
made the mistake of feeding the monster and you can't take that back.

Of course, in all these cases, there's a risk that some people will
recommend these programs for other cases, and that's a real risk.

In fact, it's in part because of this kind of risk that I'm still not
entirely decided on how to deal with Free drivers that load
user-supplied firmware, when there isn't known Free firwmare for that
device.

If we publish Linux-libre without these drivers, or with these drivers
disabled, devices won't work.  This won't stop people from asking
around.  They will get answers such as “this won't work with
Linux-libre, install this other kernel instead” or “this won't work
unless you install this firmware file”.

If we outright drop the modules, odds are that people who are
sufficiently serious about freedom as to want to run Linux-libre, but
who made the mistake of purchasing a computer with parts whose
manufacturers doesn't respect their freedom, would have to choose
between:

- following the advice of running the other kernel instead, and risk
ending up with even more non-Free Software

- extracting the modules from Linux and rolling their own kernels, or
just the modules at hand, to enable the computer to keep on working
until they're able to purchase another computer

- living without the functionality, making a silent personal sacrifice
that, socially-speaking, is mostly useless, for it doesn't take away
from the monster the power it was given when the computer was purchased,
and the user doesn't lose any further freedom by keeping on using it.

Of course I can see the social and individual benefit of being able to
say “I couldn't find a computer with a <whatever-doing> device that
would work with 100% Free Software, so I had to get one with such a
device, but I don't use it because I care about my freedom” rather than
“I chickened out and ended up using the device anyway” or “When I got
the computer, I didn't know it had this device, and I didn't know the
kernel uploaded non-Free firmware for it to work, but now I can't return
it any more, so I might just as well use it, since all the harm is
already done”.  But while I find the first position admirable and I wish
everyone would take it, I don't feel it's right to demand people to take
it.


Whereas, if we were to enabled the modules, odds are that those who are
determined to not fall in the trap will refuse to install the firmware
anyway, those who aren't ready to get out of it will install just the
poison they're addicted to (and know about it), and those who just don't
care will probably not even have tried Linux-libre anyway, and if they
did, they probably wouldn't hesitate to drop it in favor of the non-Free
Linux.


So, on the one hand, I like the idea of maximizing users' freedom, by
not inducing people who are determined to keep on using some non-Free
Software to switch back to non-Free Linux after finding out their
hardware requires it, and rather paving a way for them to keep deprived
of just the amount of freedom they feel comfortable giving up (ideally
as long as it doesn't harm others and doesn't spread).

On the other, I see the argument that this would make it too convenient
for one to sacrifice one's own freedom, even if it hadn't been
sacrificed before, to the point of further feeding the monster.  I guess
just requesting firmware files with different names, so as to remind
them of the issues of freedom, isn't enough to shift the balance against
sacrificing freedom.

But then, building modules for Linux-libre that would load (or include)
the non-Free firmwares isn't rocket science either, and they might even
be distributed, unlike some well-known non-Free drivers that can only be
distributed in source form.

So I guess I still don't see very clearly that disabling or even
excluding the modules will accomplish much for our cause.  Am I looking
at it from the wrong perspectives?


> We should change these drivers to make report clearly "This device is
> not supported" instead of trying to load the blob.

That's an interesting thought.  This could be accomplished by as little
as changing the name of the requested firmware file, or changing the
call to request_firmware, or some such.

I'm still not entirely sold on the idea of making it impossible to get
any firmware whatsoever loaded by such drivers, although I can see that,
once Linux moves all firwmare elsewhere, this could be the main
distinction between it and Linux-libre.

However, disabling drivers or firmware requests feels far less laudable
than removing the non-Free Software itself.  Unless I manage to
understand good social and strategic reasons to drop support for them
altogether, rather than make room for freedom of choice where it might
be put to use without harming others, and keep our focus on education, I
think I'll have a much harder time defending this project than I do now
:-(

>     And then, there may be other drivers that we never even looked at, that
>     used the userland firwmare-loading interface and external firmware all
>     the way from the beginning and so never triggered our blob-searching
>     efforts.

> Can we find them because they call a certain function to load the
> firmware file?

We can trivially locate drivers that request firmware.  The difficulty
might be in locating the firmware itself, to tell whether it's Free or
non-Free.

> Whenever a driver calls the firmware-loading interface
> to load firmware which isn't free,

It's the “which one isn't Free?” question that's hard to answer.  And it
doesn't help that the answer may change over time, without any change
whatsoever to the driver in question.  This tends to make me lean
towards trusting the user to do what's right, although past experience
doesn't quite make this sound like a clever assumption to make :-(

> This might be easier than the changes we make now.

It is, indeed.  Quite trivial, even.

However, I'm not convinced it's worth doing.  I mean, if we just disable
the driver (as in preventing it from being compiled in the first place),
like we do now (for nearly all such drivers), this change won't make any
difference.  So I'm not entirely convinced it's worth doing.

The only thing I'm sure about at this point is that it's a difficult
call :-(  At least for me it is.  I kind of hope I'm missing something
obvious here.  Help? (more :-)

Thanks,

-- 
Alexandre Oliva           http://www.lsd.ic.unicamp.br/~oliva/
You must be the change you wish to see in the world. -- Gandhi
Be Free! -- http://FSFLA.org/   FSF Latin America board member
Free Software Evangelist      Red Hat Brazil Compiler Engineer