In electronic systems and computing, firmware is a term often used to denote the fixed, usually rather small, programs and/or data structures that internally control various electronic devices. Typical examples of devices containing firmware range from end-user products such as remote controls or calculators, through computer parts and devices like hard disks, keyboards, TFT screens or memory cards, all the way to scientific instrumentation and industrial robotics. Also more complex consumer devices, such as mobile phones, digital cameras, synthesizers, etc., contain firmware to enable the device's basic operation, as well as to implement higher-level functions.
There are no strict boundaries between firmware and software, as both are quite loose descriptive terms. However, the term firmware was originally coined to contrast with higher-level software which could be changed without replacing a computer hardware component. Firmware is typically involved with very basic low-level operations, without which a device would be completely non-functional. Firmware is also a relative term, as most embedded devices contain firmware at more than one level. Subsystems such as CPUs, flash chips, communication controllers, LCD modules, and so on, have their own (usually fixed) program code and/or microcode, regarded as "part of the hardware" by the higher-level (s) firmware.
Low-level firmware typically resides in a PLA structure or in a ROM (or OTP/PROM), while higher-level firmware (often on the border to software) typically employs flash memory to allow for updates, at least in modern devices. (Common reasons for updating firmware include fixing bugs or adding features to the device. Doing so usually involves loading a binary image file provided by the manufacturer into the device, according to a specific procedure; this is sometimes intended to be done by the end user.)
Thus, while high-level firmware (or software) typically is stored as a configuration of charges, low-level firmware may instead often be regarded as actual hardware. For instance, older firmware was often implemented as a discrete semiconductor diode matrix. The modern equivalent is an integrated matrix of field effect transistors, where 0's and 1's are represented by whether a particular component in the ROM and/or PLA matrices is present or not.
Origin of the term
Ascher Opler coined the term "firmware" in a 1967 Datamation article. Originally, it meant the contents of a writable control store (a small specialized high speed memory), containing microcode that defined and implemented the computer's instruction set, and that could be reloaded to specialize or modify the instructions that the central processing unit (CPU) could execute. As originally used, firmware contrasted with hardware (the CPU itself) and software (normal instructions executing on a CPU). It was not composed of CPU machine instructions, but of lower-level microcode involved in the implementation of machine instructions. It existed on the boundary between hardware and software; thus the name "firmware".
Later application of the term broadened to include any type of microcode, whether in writable control store or read-only control store.
Still later, popular usage extended the word "firmware" to denote anything ROM-resident, including processor machine-instructions for BIOS, bootstrap loaders, or specialized applications.
Until the mid-1990s, updating firmware typically involved replacing a storage medium containing firmware, usually a socketed ROM. As of 2009, firmware upgraders have largely abandoned this approach, in favor of using firmware's capability to overwrite itself in a convenient, purely electronic operation.
IEEE definition
The Institute of Electrical and Electronics Engineers (IEEE) Standard Glossary of Software Engineering Terminology, Std 610.12-1990, defines firmware as follows:
- "The combination of a hardware device and computer instructions and data that reside as read-only software on that device.
- Notes: (1) This term is sometimes used to refer only to the hardware device or only to the computer instructions or data, but these meanings are deprecated. (2) The confusion surrounding this term has led some to suggest that it be avoided altogether."
Firmware as of 2012
Today, in some circles, the word firmware has evolved to sometimes even denote application-level programs stored in NAND flash or NOR flash memory (such as in mobile phones and similar products). However, a more fundamental definition would still be fixed or semi-fixed data in a hardware device. This may include ROM and/or PLA structures for microcode and other data in a processor implementation, as well as the low-level machine code stored in ROM or flash memory running on that processor (i.e. many products use several levels of firmware). Microcode and other data in an application-specific integrated circuit (ASIC) would also fit that definition very well. The same could be said about programmable logic devices which may have configuration data stored either as internal fuses, in a ROM, or in a flash memory (used much the same way as a ROM or EPROM).
Personal computers
In some respects, the various firmware components are as important as the operating system in a working computer. However, unlike most modern operating systems, firmware rarely has a well-evolved automatic mechanism of updating itself to fix any functionality issues detected after shipping the unit.
Currently, devices like video cards, sound cards or modems in a modern PC often rely on firmware dynamically loaded by a device driver and may thus get transparently updated through the operating system update mechanisms. The BIOS may be "manually" updated fairly easily by an educated user, using a small utility program. In contrast, firmware in storage devices (harddisks, DVD drives, flash storage) rarely gets updated, even when flash (rather than ROM) storage is used for the firmware; there are no standardized mechanisms for detecting or updating firmware versions. However, in practice, such devices have a low rate of functionality issues, compared to parts where the firmware may be updated. This is because, in most cases, only small incremental changes to the code are needed for new product generations. The bulk of the code is therefore typically well proven and tested, compared to completely new, or less critical, products. The amount of in-depth design analysis and serious testing also varies heavily among different product groups in general, according to market demands, corporate culture and other factors.
Computer peripherals
Most computer peripherals are themselves special-purpose computers. While external devices (printers, scanners, cameras, USB drives,...) have firmware stored internally, modern graphics cards and peripheral expansion cards often have parts of the firmware loaded by the host system at start-up, as this provides greater flexibility. Such hardware may therefore fail to function fully until the host computer has "fed" it the requisite firmware, typically via a specific device driver (more exactly: via a start-up subsystem within a device driver package). Modern device drivers, whether for internal or external "peripheral" devices, may also expose a direct graphical user interface for configuration, often using parts of a normal application programming interface, in addition to lower-level operating system calls, hooks, and/or other interfaces designed for device drivers.
Consumer products
As of 2010 most modern portable music players support firmware upgrades. Some companies use firmware updates to add new playable file formats (encodings); iriver added the Vorbis format this way, for instance. Other features that may change with firmware updates include the GUI or even the battery life. Most mobile phones have a Firmware Over The Air firmware upgrade capability for much the same reasons; some may even be upgraded to enhance reception or sound quality, illustrating the fact that firmware is used at more than one level in complex products (in a CPU-like microcontroller versus in a digital signal processor, in this particular case).
Automobiles
Since 1996 most automobiles have employed an on-board computer and various sensors to detect mechanical problems. As of 2010 modern vehicles also employ computer-controlled ABS systems and computer-operated Transmission Control Units (TCU). The driver can also get in-dash information while driving in this manner, such as real-time fuel-economy and tire-pressure readings. Local dealers can update most vehicle firmware.
Examples
Examples of firmware include:
- Consumer products:
- Timing and control systems for washing machines
- Controlling sound and video attributes, as well as the channel list, in modern TVs
- EPROM chips used in the Eventide H-3000 series of digital music processors
- In computers
- The BIOS found in IBM-compatible personal computers
- The platform code found on Itanium systems, Intel-based Mac OS X machines, and many Intel desktop boards is EFI-compliant firmware
- Open Firmware, used in computers from Sun Microsystems, Apple, and Genesi
- ARCS (computing), used in computers from Silicon Graphics
- Kickstart, used in the Amiga line of computers (POST, hardware init + Plug and Play auto-configuration of peripherals, kernel, etc.)
- RTAS (Run-Time Abstraction Services), used in computers from IBM
- The Common Firmware Environment (CFE)
Firmware hacking
Sometimes third parties create an unofficial new or modified version of firmware to provide new features or to unlock hidden functionality. Examples include:
- Rockbox for digital audio players.
- CHDK and Magic Lantern for Canon digital cameras.
- Nikon Hacker project for Nikon EXPEED DSLRs.
- Many third-party firmware projects for wireless routers, including:
- OpenWrt for wireless routers.
- RouterTech – for ADSL modem/routers based on the Texas Instruments AR7 chipset (with the Pspboot or Adam2 bootloader).
- List of wireless router firmware projects
- Firmware that allows DVD drives to be region-free.
- SamyGO, modified firmware for Samsung televisions.
- Many homebrew projects for gaming consoles. These often unlock general-purpose computing functionality in previously limited devices (e.g., running Doom on iPods).
Most firmware hacks are free and open source software as well.
These hacks usually take advantage of the firmware update facility on many devices to install or run themselves. Some, however, must resort to exploits in order to run, because the manufacturer has attempted to lock the hardware to stop it from running unlicensed code.
Newer custom firmware hacks have also focused on injecting malware in devices such as smartphones. One such injection was demonstrated on the Symbian OS at MalCon, a hacker convention.