I wrote a response to this post on 2021 April 22.

In my opinion, all hardware should be free-design (as in freedom), but we're not in a place where that's feasible. Practically speaking, it's a lot harder to make hardware than it is to make software. And very few hardware makers are making free hardware. So pragmatically, we must accept nonfree hardware.

This then leads to the question of firmware running on the hardware. Firmware is software, and all software should be free, so the firmware should be free. Ideally, all hardware firmware would be free.

This is (of course) not the case. So how do we, the free software community, handle hardware which can only run with nonfree firmware?

According to the FSF/GNU/RMS, it's unacceptable for hardware to require the operating system to provide nonfree firmware for it, but if the same nonfree firmware is baked into the hardware device, it's fine. The FSF's Respects Your Freedom (RYF) program criteria say that the product must use 100% free software, with an exception for "secondary embedded processors" on which users are not intended to install software after they get the product.

In other words, consider two Wi-Fi cards, card A and card B, both of which require the nonfree X-firmware to function. Card A expects the operating system to load X-firmware onto it each time it's plugged in. Card B already has X-firmware installed onto it, and this firmware cannot be changed. In this situation, card B "respects your freedom" because you don't have the option to install firmware (free or not) on it, while card A does not respect your freedom because you must install firmware on it, and the only firmware available is nonfree. Even though they're both running the same nonfree software, not being able to change that software somehow makes it okay.

I believe this is a direct haskal quote on the matter: "this is a pretty arbitrary distinction." Both are running nonfree software. In fact, in this situation, card A has the potential to one day run free software, if free software is developed for it, while the only hope for card B is that the company that wrote X-firmware one day releases it under a free license. An argument could be made that card A is actually more free because it at least allows the user to change it, even if the only current options for change are nonfree.

Now, there's also some logic to the FSF argument. RMS argues that "Firmware that is installed during use is software; firmware that is delivered inside the device and can't be changed is software by nature, but we can treat it as if it were a circuit." This makes some sense in a world where free hardware is an ideal but not a reality in almost all cases. It's a somewhat pragmatic approach. We can choose not to worry about how our hardware peripherals work as long as we can use them with our free operating system. I don't worry too much about how my USB mouse works, for instance, even though it's running some software, and I'm sure that software isn't free.

(This also makes a lot of sense if your primary goal is to create an operating system that is, in entirety, free software. If the firmware is loaded by the OS, you have to either include it in your OS or not have a working device. If the firmware isn't loaded by the OS, it becomes someone else's problem.)

Personally, I don't really have a well-defined pragmatic stance on the matter. I can appreciate the arguments from both sides. In theory, all hardware should be free, and there should be no nonfree firmware. In practice, almost all computers will need some nonfree firmware, and expecting people to spend money on new hardware (especially instead of reusing older hardware) is both classist and wasteful. (As a sidenote, I want to write a post on how the free software movement's approach to things is sometimes victim blaming - blaming people for using nonfree software, rather than blaming the tech companies and culture that force this nonfree software upon them.) For most people, accepting the reality of nonfree firmware is a necessary evil.

The stances in the previous paragraph don't actually addresses the matter at hand. I think personally here is my order of preference:

1. Free-design hardware
2. Nonfree-design hardware with free firmware
3. Nonfree-design hardware with nonfree firmware baked-in
4. Nonfree-design hardware with nonfree firmware loaded by the OS

I chose this order simply because it's easier to rationalize a peripheral as separate from the system when the system doesn't have to give it firmware. ("At least it works with my libre computer.") But practically speaking, I recognize that 3 is not really different from 4, and 1 and 2 are preferable.

Conclusion

I don't think there's a "right" answer for absolute software freedom under current hardware constraints. I think the Fedora model of software freedom (all software in Fedora must be free with the exception of redistributable firmware so Fedora can boot on as many computers as possible) is a very reasonable stance for most people.