Got a new printer (a nice Epson to replace the HP hunk o’junk we’ve been struggling with), and it said it needed a firmware update.
I clicked the appropriate buttons on the Epson interface, and the printer whirred happily to itself.
So was I updating the software that’s pre-installed in the printer?
Yes, firmware is the built-in software that controls various hardware like printers, TV’s, remote controls, gas pumps, bar-code scanners etc. It is independent of the PC and generally works fine but sometimes there are known glitches that need to be fixed through an update. You should be fine.
Yes. There’s little real difference between “firmware” and “software” except that firmware tends to be resident in non-volatile erasable ROM inside an appliance or hardware component instead of the dynamic RAM of a general-purpose computer. But ultimately firmware is just a specialized microprocessor program that someone designed and wrote and, hopefully, tested.
I find it odd to hear an HP printer referred to as “junk” as there was a consensus here recently that I agree with that was strongly in favor of HP laser printers. I’ve had my present HP Laserjet practically forever and it’s still going strong.
From the moment we got the HP (jet, not laser) we were plagued with:
Paper jams;
False notifications that the printer was out of paper;
False signals that the print carriage was jammed.
The day before we trashed it, I was trying to print some docs. Every single page the printer stopped and said it was out of paper. I would have to pull out the full tray of paper and push it back in. It would print one page, then signal it was out of paper.
Then, practically every page it would say that the printer carriage was jammed. So I would open the printer and close it, magically clearing the jammed printer carriage.
There were also repeated problems with it dropping the signal from our wi-if, but that may have been a router issue.
For what it is worth, I’ve owned three different HP printers in the 25+ years I’ve worked with home computers, and I’ve had significant issues with none of them. I won’t even comment on the difficulties I had with the one Dell printer that I owned (came with the computer); I replaced it with my current HP inkjet multi-function printer/scanner/fax/copier.
Firmware, as I understand the term, is intended to identify software that runs a device installed by the manufacturer, and for which updates are obtained from the manufacturer. This is as opposed to an operating system, for example, installed on a computer that is from a different company (Windows on a Dell, for example). Of course, that’s just a guideline; I don’t think anyone calls OS X “firmware” on a Mac.
If you, like the OP, have weird problems with a printer, you may want to update the firmware. You can check on the manufacturer website to see what fixes the firmware update includes, as it might specifically mention the problem you’re having. But even if it does not, it’s usually a good idea to update the firmware. One reason is that if you contact the manufacturer about the problems you’re having, they’ll almost certainly ask you to update the firmware in the process of diagnosing the issue.
Firmware used to be firmer. Everything with a digital display (and a lot of stuff that doesn’t) has software of some kind, but it would typically be programmed once at the factory and never again. Very rarely, if there were a serious bug, there might be a recall to upgrade the software–like for the computers on a car.
But now every printer and TV and console box and fuckin’ microwave has an internet connection, and hence gets semi-regular updates. So it’s all just software now. You can’t even differentiate based on firmware living in “non-volatile memory”, since computer SSDs are likewise just non-volatile memory.
That is true, and the original definition of firmware was microcode, the code which underlies and implements each machine instruction on a microcoded CPU. This was the most accurate and logical definition since it wasn’t hardware, nor software by the usual viewpoint. Conceptually it was something in between, thus the term firmware.
The more recent definition of firmware which refers to almost any embedded software is really not accurate since it is simply software in non-volatile storage. This has now reached the point where an iOS software update is commonly referred to as a firmware update. It is just software made up of Ax CPU machine instructions.
However since most people no longer know what microcode is (even among computer professionals), it’s just as well the term was repurposed. It wouldn’t make sense to leave that term “on the shelf” and off limits since there is a better use for it. People commonly now understand “firmware” to be any software running on an embedded or portable device, so the word fulfills the basic purpose of language which is to communicate concepts.
It’s not really the “non-volatile” part per se that characterizes firmware, it’s the fact that generally speaking it permanently lives on a ROM and is dedicated to a single function. Main memory was non-volatile once, too, when it was based on ferrite core technology, but the OS still dynamically booted into RAM from secondary storage. SSDs are just storage, not main memory.
The original concept of “firmware” was that it was software that was so intrinsically embedded in the hardware that it was indistinguishable from the hardware itself, yet it was programmatic in nature – hence, that it lived in a twilight zone that was neither hardware nor software. A related but different concept back in the day of discrete-logic computers was microprogramming, where a computer’s instruction set could either be hardwired or implemented in specialized microcode. The microcode controlled relatively low-level logic functions so it was pretty exotic stuff that looked nothing like conventional machine language – it was the programmatic equivalent of backplane wiring. Today, the distinction between firmware and software is pretty arbitrary.
[ETA: Partly ninja’d by joema!]
I’ll also add: I would consider tablets and smartphones to run an OS, not firmware, because the OS boots from secondary storage and is distinguishable from the apps that it runs. The Kindle is in a gray area – it goes through a boot process (though it’s almost never necessary) but there is no distinction between the OS and its primary application, but OTOH it’s sufficiently general-purpose that it has a sort of browser.
I’ve never heard of microcode being called firmware, but I’m sure others have; in my experience, microcode has always been called microcode: It’s the semi-magical stuff that implements machine code, the instructions that directly control the lowest-level components of the CPU such that an infinite loop in the microcode would cause the processor to lock up hard and not even the OS could save you.
Firmware, on the other hand, was very low-level software that controlled specific pieces of hardware like, yes, printers, but also hard drives and external modems and computer monitors, in addition to the more familiar piece of firmware that was the BIOS; firmware was in ROM, not NVRAM (non-volatile RAM), and as such it was essentially part of the hardware: You weren’t going to change it without a soldering iron and a few new chips or, in other words, physical modifications to the hardware.
The Kindle runs Linux. It’s a tiny little Linux box which boots and then runs the Kindle application software. It seems a bit odd to me to call a multi-tasking OS “firmware”, but I guess it might meet the definition these days.
Fully understood–it’s just that we spent a few decades where computer storage, both for data and program code, was on a hard drive. Whereas firmware, despite being conceptually identical, generally lived on a PROM of some kind, including both EPROMs and EEPROMs. I think I still have a little UV box around for erasing EPROMs.
So even though it had nothing to do with the definition, chances are that if your code lived on a chip, then it was something akin to firmware, while if it lived on a hard drive it was software. But even that imperfect distinction is slowly fading with flash memory. And we may yet go back to the era where both storage and memory are non-volatile.
Microcode still exists in your CPU, and can likewise be reprogrammed. As you say, it’s pretty exotic–it implements the instruction set of your CPU, so it exists at a lower level than even that. Even this gets patched on a regular basis, usually to fix security holes.
The software in a Roku box is pretty universally called “firmware”, both by people on the outside and by the Roku engineers who develop it. It’s just an ordinary Linux distribution, a multitasking OS running a variety of user applications. There’s really nothing very “firm” about it from a hardware viewpoint. It’s just the fact that it’s software that’s dedicated to running an appliance that makes people tend to call it firmware.
It seems there are a few patterns leading to the “softening” of firmware:
[ul]
[li] Internet connections everywhere. If you always have a direct line to the manufacturer, then it’s easy to get updates.[/li][li] General improvement in the deployment process. Once you had to download a special DOS program with arcane command line options to update your computer’s BIOS. Now you click a button on a fancy GUI program (FWIW, I still use arcane command line flash programs on a regular basis).[/li][li] Increase in sophistication of consumer devices. A pocket calculator doesn’t need updates. Today’s “moral equivalent” of a calculator is probably something like an e-reader. Which, as mentioned, runs a full OS; probably Linux based. It’s tough to call that firmware even though it runs an embedded system.[/li][li] Going along with the increase in sophistication is an increase in bugs. More complex software needs more support.[/li][li] And more cynically, hardware companies have learned that they can push out more half-baked devices and patch them later, due to all of the above. Ship early and fix later.[/li][/ul]
Wolfpup, Ferrite core memory was very volatile. When an address location was read, it was erased and had to be rewritten with the same information. Slowed things down quite a bit. I am not really sure what the first non-volatile memory was, although some of the early Univac computers had programs/data stored on magnetic drums, so possibly they were the first.
Bob
Ferrite cores had to be dynamically refreshed, but they were nonvolatile when the power was off as long as nobody shook them too hard or whacked them with a two-by-four or something.
It used to be that the dividing line between software and firmware was pretty clear. Software was something that was loaded from disk or loaded from firmware (or in some cases loaded from a network), and when you turned off the machine, the software went away and would have to be reloaded. Firmware, on the other hand, was stored in ROMs. Some ROMs were not programmable, but the ones that were typically needed to be removed from the device and reprogrammed, like UV erasable PROMs.
With modern technology, the dividing line isn’t so clear. In one of our industrial controllers, the boot code is stored on a disk-on-chip. It’s a chip that plugs into a socket on the main CPU board, but from the software and the CPU’s point of view it looks like a disk drive. The CPU even recognizes it as an IDE drive, though it’s really just a flash disk. Like typical firmware of old, we program it in a chip programmer and shove it into the socket on the CPU board during the assembly process. If we update it, we send out new chips and our field technicians install them, just like old style firmware. On the other hand, it’s basically a flash disk. For development, we attach a keyboard to the machine and transfer files to the disk to create its boot programs. From the developer’s point of view, it’s just like any other hard drive. So, is it firmware, or software? We call it firmware.
As devices become more and more intelligent in general, and as embedded controllers become more powerful and less expensive, you often find off-the-shelf embedded CPU/controller boards put in products like printers and such, and they often boot from a flash disk. When you download new “firmware” for the device, all it does is write new files onto the flash disk. You could take the same CPU board, connect it to an external monitor and keyboard and a mouse, and run it as a general purpose computer. Then the files on the flash disk would be called “software” instead of “firmware”. But there’s no real functional difference between the two.
These days, software on an embedded system’s flash disk is typically called firmware, even though exactly how “firm” it is may be a matter of debate. The exact dividing line between firmware and software is definitely a bit blurry.
“Sounds like somebody’s got a case of the ‘Mondays’”.
One more relevant point regarding Printer firmware updates, updating may prevent the use of third party replacement ink cartridges in your device. Unless you have a problem and wish to guarantee your continued use of less expensive ink carts I’d leave well alone.
Peter
I don’t know if this is still valid, or ever really was, but the one thing about firmware updates that always puts the fear of God into me is I was told Never Ever disconnect or otherwise interrupt one, because unlike a software update–which I liken to a school lesson–a firmware update is actual brain surgery, and if you interrupt it your device is left permanently damaged.
Is this true?