A typical firmware-controlled device, a television remote control
In
electronics and
computing,
firmware is a term often used to denote the fixed, usually rather small, programs and 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 implementing higher-level functions.
No strict or well-defined boundaries separate firmware from
software; both are quite loose descriptive terms. However, firmware is typically involved with very basic low-level operations in a device, without which the 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
LCD modules,
flash chips, communication controllers etc, have their own (usually fixed) program code and/or
microcode, regarded as "part of the hardware" by the higher-level firmware.
Simple firmware typically resides in
ROM or OTP/
PROM, while more complex firmware often employs
flash memory to allow for updates. 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 (by the device manufacturer) to be done by the end user.
Origin of the term
Ascher Opler coined the term "firmware" in a 1967
Datamation article.
Originally, it meant the
microcode – contents of a
writable control store (a specialized small area of
RAM memory), which defined and implemented the computer's
instruction set. If necessary, one could re-load the firmware 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 RAM or ROM.
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 to a new version typically involved replacing a
storage-medium containing firmware, usually a socketed ROM. firmware-upgraders have largely abandoned this approach in favor of using firmware's capability to overwrite itself in a convenient, purely electronic operation.
Firmware
The concept of "firmware" has evolved to mean almost any programmable content of a hardware device, not only
machine code for a processor, but also configurations and data for
application-specific integrated circuits (ASICs),
programmable logic devices, etc.
Computer peripherals
Most computer peripherals are themselves special-purpose computers. While external devices have firmware stored internally, as of 2009 modern computer peripheral cards typically have large 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, often via the specific
device driver (or, more exactly, via a subsystem within a device driver package). , modern device drivers may also expose a direct user-interface for configuration in addition to the fundamental operating system calls/interfaces or
application program interfaces (APIs).
Firmware challenges in PCs
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, one can fairly easily update the BIOS in a modern PC; devices like video cards or modems often rely on firmware dynamically loaded by a device driver and may thus get transparently updated through the
operating system update mechanisms. In contrast, firmware in storage devices rarely get updated; even when flash (rather than ROM) storage is used, there are no standardized mechanisms for detecting and updating firmvare versions. However, in practice, such devices have a low rate of functionality issues compared to parts where the firmware may be updated. The reasons for this probably belong to the realm of psychology; a partial explanation could postulate that designers (programmers) may not invest as much energy in error-proofing code which they know they can easily update, as compared to when it "must be" correct in the very first production-run. A difference in complexity may be another factor, as devices with fixed firmware tend to be simpler.
Portable music players
Some companies use firmware updates to add new playable file formats (encodings);
iriver added the
ogg format this way, for instance. Other features that may change with firmware updates include the GUI and even the battery life. most modern music players support firmware upgrades.
Mobile phones
Most mobile phones have a firmware upgrade capability for much the same reasons as above, but some may even be upgraded to enhance reception or sound quality.
Automobiles
Since 1996 most
automobiles have employed an on-board computer and various sensors to detect mechanical problems. modern vehicles also employ computer-controlled ABS systems and computer-operated
Transmission Control Systems (TCS). 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.
IEEE Definition
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."
Examples
Examples of firmware include:
- The BIOS found in IBM-compatible personal computers
- Kickstart used in Amiga line of computers: a unique example of a firmware mixing BIOS capabilities (POST, hardware init + Plug and Play auto-configuration of peripherals, etc.), the Kernel itself of the AmigaOS and parts of code used in the OS (Such as Graphical Interface primitives and libraries)
- RTAS (Run-Time Abstraction Services), used in computers from IBM
- EPROM chips used in the Eventide H-3000 series of digital music processors
- Controlling sound and video attributes as well as the channel list in modern TVs
Firmware "hacking"
Sometimes third parties may write an unofficial new or modified version of firmware to provide new features or to unlock hidden functionality. Examples include:
- CHDK
- region free firmware for DVD-drives, which are not region free with the official firmware
- many homebrew projects for gaming consoles. These can 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. See also
