Low Pin Count
The Low Pin Count (LPC) interface is a low-pin-count bus specification developed by Intel Corporation to connect low-bandwidth peripherals, such as floppy disk controllers, serial and parallel ports, and PS/2 keyboard/mouse interfaces, to the CPU or chipset in personal computers, effectively replacing the older Industry Standard Architecture (ISA) bus while reducing pin requirements and system costs.[1][2] Announced on September 29, 1997, as part of Intel's strategy to migrate legacy I/O from ISA-based systems to PCI-centric platforms, the LPC interface was designed to support the transition to ISA-less motherboards by providing software-transparent compatibility for existing peripherals without requiring special drivers.[2] The specification, first released in revision 1.0 and later updated to revision 1.1 in August 2002 to include firmware memory cycles and electrical clarifications, enables synchronous operation at the PCI clock speed of 33 MHz, serializing data over a multiplexed 4-bit bus to achieve or exceed ISA's performance for targeted applications.[1][2] Key technical features of LPC include a minimal pin count of six signals—LAD[3:0] for address/data multiplexing, LFRAME# for frame delineation, and LDRQ# for DMA requests—along with support for memory, I/O, DMA, bus master, and firmware memory transactions of 1, 2, 4, or 128 bytes. This design reduces space, power consumption, and thermal demands compared to the 98-pin ISA bus, facilitating integration into southbridge chipsets and super I/O devices while promoting the adoption of emerging interfaces like USB and IEEE 1394.[2] Although largely superseded in modern systems by enhanced Serial Peripheral Interface (eSPI) and other buses, LPC remains relevant in legacy-compatible embedded and industrial PC designs as of 2025.[4][5]History and Development
Origins and Purpose
The Low Pin Count (LPC) interface was developed by Intel Corporation and announced on September 29, 1997, at the Intel Developer Forum in San Francisco, as a means to facilitate the transition from legacy ISA bus-based systems to modern PCI-centric platforms in personal computers.[2] This specification, initially released as Revision 1.0, aimed to replace the aging Industry Standard Architecture (ISA) and X-bus interfaces that had become inefficient for integrating low-bandwidth peripherals on motherboards.[1] By introducing a streamlined serial-like protocol, LPC enabled the elimination of full ISA slots while preserving essential connectivity for embedded components.[2] The primary motivations for LPC's creation were to drastically reduce the pin count required for chipset and peripheral integration, thereby lowering manufacturing costs and simplifying motherboard designs in the post-PCI era. Traditional ISA interfaces demanded approximately 36 dedicated signals for address, data, and control lines, contributing to larger, more expensive chip packages—such as 160-pin devices for Super I/O controllers.[1] In contrast, LPC achieves a net savings of about 30 pins per peripheral by introducing only six new signals (LAD[3:0] for multiplexed lines, LFRAME#, and LDRQ#), while sharing existing PCI clock (LCLK) and reset (LRESET#) signals, resulting in 6 to 13 total pins depending on implementation.[1] This reduction not only cut package sizes (e.g., from 160 to 88 pins for Super I/O chips) but also eased routing on high-density boards, addressing the space and cost constraints of x86-based IBM-compatible PCs.[1][2] Furthermore, LPC was designed to maintain full backward compatibility with ISA software and cycle types, including memory reads/writes, I/O operations, DMA, and bus mastering, ensuring transparency to operating systems and BIOS without requiring application changes.[1] It targeted low-bandwidth peripherals such as floppy disk controllers, keyboard/mouse interfaces, serial/parallel ports, audio codecs, and BIOS firmware hubs, typically housed in southbridge chipsets or Super I/O devices on desktop and mobile systems.[2] By multiplexing address, data, and commands over a narrow 4-bit bus synchronized to a 33 MHz PCI clock, LPC supported these functions efficiently while enabling a phased migration: first integrating legacy I/O via LPC, then removing ISA slots, and ultimately phasing out physical legacy ports in favor of USB and other high-speed alternatives.[1][2] This approach addressed key ISA limitations, such as restricted memory addressing (up to 16 MB) and asynchronous timings, by expanding support to 4 GB and adopting synchronous PCI-like operations.[1]Specifications and Revisions
The Intel Low Pin Count (LPC) Interface Specification serves as the primary document defining the LPC bus, initially released on September 29, 1997, as Revision 1.0 without an assigned document number.[2][1] This specification was developed to enable low-bandwidth connections in x86-based systems while promoting open implementation among designers and vendors.[1] Revision 1.1, released in August 2002 with document number 251289-001, introduced key enhancements including support for firmware memory cycles to facilitate BIOS and other firmware access through multi-byte read and write operations (1, 2, 4, or 128 bytes).[1] It also provided electrical clarifications for signals such as LPCPD# (an optional power-down indicator) and LSMI#, along with updated requirements for system reset, pull-up resistors, and clock signals like LRESET#, LCLK, and CLKRUN#.[1] For compliance, LPC implementations must operate at a 33 MHz clock synchronous with PCI timing and include mandatory signals: LAD[3:0] for multiplexed command, address, and data; LFRAME# for cycle framing; LRESET# aligned with PCI reset; and LCLK as the reference clock.[1] Optional signals, such as SERIRQ for serialized interrupt handling, LDRQ# for DMA requests, CLKRUN# for mobile clock management, LPME# for power events, LPCPD#, and LSMI# for system management interrupts, may be included based on system needs.[1] No official revisions to the LPC specification have been issued by Intel since 2002; subsequent integrations appear in chipset documentation, such as the Intel 8 Series Chipset Platform Controller Hub, which references LPC for legacy support until the emergence of the Enhanced Serial Peripheral Interface (eSPI) in 2012.[6]Technical Specifications
Signals and Pinout
The Low Pin Count (LPC) interface utilizes a minimal set of signals to connect low-bandwidth peripherals to the host chipset, replacing the extensive pin requirements of the legacy ISA bus. It employs seven required signals and up to six optional signals, resulting in a total of 6 to 13 pins depending on implementation. This design leverages a simple parallel interface akin to PCI sideband signals, enabling efficient communication with reduced complexity.[1] The required signals form the core of the LPC bus. The LAD[3:0] lines serve as a bidirectional, multiplexed 4-bit bus for command, address, and data transfer, allowing serialization of information across the interface. LFRAME# is an active-low input/output signal that provides frame synchronization, indicating the start or termination of a bus cycle. LRESET# acts as the system reset signal, shared with the PCI bus, which initializes the interface and tri-states the LAD lines when asserted. Finally, LCLK delivers a 33 MHz clock reference, synchronous with the PCI clock, to drive all operations.[1] Optional signals enhance functionality for specific use cases, particularly in power management and legacy support. LDRQ# enables encoded DMA or bus master requests from peripherals, with one line typically per device. SERIRQ supports serialized interrupt requests, allowing multiple peripherals to share a single line via a daisy-chain protocol. CLKRUN# facilitates clock throttling for mobile or low-power systems. LPME# signals power management events, such as wake-up requests from sleep states. LPCPD# indicates impending power-down to prepare peripherals before clock cessation. LSMI# conveys system management interrupts, often used for retry mechanisms in I/O operations.[1] In terms of pinout efficiency, the LPC interface achieves significant savings over the ISA bus, which required approximately 100 pins including data lines (D[7:0]), address lines (SA[23:0]), and control signals. LPC reduces this to as few as 6 pins for basic operation (LAD[3:0], LFRAME#, and shared reset/clock), with a net savings of about 30 pins on peripherals, enabling smaller package sizes such as from 160-pin to 88-pin or less.[1] Signal characteristics emphasize compatibility with PCI electrical standards for reliability and interoperability. The LAD[3:0] and SERIRQ signals operate in open-drain mode, while others like LFRAME#, LRESET#, and LCLK use push-pull drivers. All signals are specified at 3.3 V levels, adhering to PCI 2.3 voltage tolerances (e.g., VOH ≥ 2.4 V, VOL ≤ 0.5 V for most lines), with LAD[3:0] required to sink up to 12 mA in low-state conditions to ensure robust bus loading. Pull-up resistors (15 kΩ to 100 kΩ) are mandated on open-drain lines like LAD[3:0] and LDRQ# when unconnected. In ISA-compatible modes, the LAD bus employs 4-bit nibble transfers to handle addressing up to 1 MB, maintaining backward compatibility without additional pins.[1]| Signal Group | Signal Name | Type | Description | Electrical Notes |
|---|---|---|---|---|
| Required | LAD[3:0] | I/O (Open-Drain) | Multiplexed Address/Data (4 bits) | 3.3 V, sink 12 mA |
| Required | LFRAME# | I/O (Push-Pull) | Frame Sync (Active Low) | 3.3 V PCI levels |
| Required | LRESET# | I (Push-Pull) | System Reset | Shared with PCI |
| Required | LCLK | I (Push-Pull) | 33 MHz Clock | Synchronous to PCI |
| Optional | LDRQ# | O/I (Open-Drain) | DMA Request | 3.3 V, pull-up required |
| Optional | SERIRQ | I/O (Open-Drain) | Serialized IRQ | 3.3 V, daisy-chain support |
| Optional | CLKRUN# | OD/I-OD | Clock Run Control | For low-power states |
| Optional | LPME# | OD/I-OD | Power Management Event | Wake-up signaling |
| Optional | LPCPD# | I/O | LPC Power Down | Assert ≥30 µs before clock stop |
| Optional | LSMI# | OD/I | System Management Interrupt | For I/O retry |
Clocking and Timing
The Low Pin Count (LPC) interface operates synchronously with a dedicated clock signal, LCLK, which is provided by the host chipset and nominally runs at 33 MHz, matching the frequency and phase of the PCI clock for compatibility.[1] This clock source ensures that all LPC transactions are timed relative to LCLK rising edges, where data on the LAD[3:0] lines is typically sampled, mimicking PCI bus synchronization to simplify integration with existing motherboard designs.[1] Additionally, the optional CLKRUN# signal allows dynamic clock throttling; when asserted low by a peripheral (e.g., during a DMA request via LDRQ#), it prevents the host from stopping LCLK in low-power states, restarting the clock if necessary to maintain bus activity.[1] Transactions on the LPC bus are framed by the LFRAME# signal, which the host asserts low to initiate a cycle and holds active for the duration of the transfer, with data and control information multiplexed on LAD[3:0] over successive LCLK cycles. LFRAME# deassertion marks the end of a cycle.[1] To accommodate slower peripherals, such as floppy disk controllers, the host can extend cycle timing by keeping LFRAME# asserted across multiple clocks or using the SYNC field in the transaction protocol; for short SYNC (0101b), up to eight wait states are supported, while long SYNC (0110b) allows indefinite extension without a fixed limit.[1] Device synchronization and initialization rely on the LRESET# signal, which the host asserts asynchronously to reset the LPC interface, tri-stating LAD[3:0] and ignoring other inputs like LDRQ# during assertion.[1] Upon deassertion, LCLK must be running, aligning with PCI reset timing protocols to ensure all devices sample the bus correctly.[1] While the LPC specification emphasizes synchronous clocking for core operations, some implementations permit asynchronous resets for LRESET#, providing flexibility in power sequencing without strict clock dependency.[1]Performance Characteristics
The Low Pin Count (LPC) bus operates at a fixed clock rate of 33 MHz using a serialized 4-bit data bus, yielding a theoretical maximum throughput of 16.5 MB/s (132 Mbps). In practice, protocol framing and synchronization overheads reduce achievable bandwidths considerably; for example, 32-bit DMA writes reach up to 6.67 MB/s, while memory reads are limited to 1.59 MB/s and I/O read/write cycles to 2.56 MB/s. Bus master transfers, which involve additional arbitration, for example achieve 1.33 MB/s for 8-bit memory reads under optimal conditions. These figures reflect the bus's design for low-to-moderate data rates rather than sustained high-volume transfers.[1] Latency in LPC transactions is influenced by framing overheads (typically 1-2 clock cycles for command and address phases) and variable wait states inserted via the SYNC field to accommodate slower peripherals, potentially causing up to 50% efficiency loss in cycles involving legacy devices. A standard I/O cycle incurs about 390 ns of latency (13 clock cycles at 33 MHz), while memory reads require around 630 ns (21 cycles, including wait states). These delays make LPC suitable for peripherals with infrequent access patterns, such as keyboards or mice, which operate at effective bandwidths below 1 MB/s even at high polling rates of 1000 Hz (e.g., 8 bytes per report).[1][7] Compared to its predecessor, the ISA bus, LPC achieves similar low-bandwidth performance but with 10-20 times fewer pins (7 required signals versus ISA's 98-pin connector, saving 30-36 signals per peripheral). This pin reduction enables more compact chip designs, such as shrinking Super I/O packages from 160 to 88 pins, without sacrificing compatibility for legacy I/O. However, LPC is not intended for high-speed applications; its maximum effective throughput pales against the PCI bus's 133 MB/s at the same 33 MHz clock.[1][8] LPC's efficiency can be modeled as: \text{Effective [bandwidth](/page/Bandwidth)} = \frac{\text{[clock rate](/page/Clock_rate)} \times \text{data width} \times \text{cycles per transfer}}{\text{total cycles including overhead}} For a 1-byte I/O transfer (requiring 13 total clock cycles including overhead), this yields approximately 2.56 MB/s, aligning with measured I/O rates and underscoring the bus's optimization for sporadic, low-volume operations like firmware queries or interrupt servicing rather than bulk data movement.[1]Protocol Overview
Transaction Structure
The Low Pin Count (LPC) interface employs a host-initiated transaction model where the host chipset drives the bus for most operations, serializing commands, addresses, and data over the LAD[3:0] bus lines using a 33 MHz clock. Each transaction consists of distinct phases: start, command/address, data, and end, framed by the LFRAME# signal to delineate cycle boundaries. This structure minimizes pin usage by multiplexing all information on four data lines, with peripherals responding only as required during specific phases.[1] The transaction begins with the start phase, lasting one clock cycle, during which the host asserts LFRAME# low and drives a 4-bit START code onto LAD[3:0] to indicate the cycle type, such as a target cycle for general peripherals. Peripherals decode this code while LFRAME# is active to determine if they should participate. The LFRAME# signal, along with LAD[3:0], serves as the primary control mechanism, with the host maintaining control of the bus throughout unless a peripheral asserts a turnaround request.[1] Following the start phase, the command/address phase occurs, where the host serializes the cycle type, direction, and address information onto LAD[3:0], most significant nibble first. This phase typically spans 5 to 9 clock cycles depending on the address size: for I/O operations, it includes 2 bits for cycle type and direction plus 16 address bits (4 cycles, totaling 5 cycles); for memory operations, it extends to 32 address bits (8 cycles, totaling 9 cycles). The serialized format ensures compatibility with low-bandwidth devices while allowing the host to specify the operation precisely.[1] The data phase follows, transferring information in 4-bit nibbles over LAD[3:0], with two clock cycles per byte: the least significant nibble first, followed by the most significant nibble. For write operations, the host drives the data after the command/address phase; for reads, a 2-cycle turnaround (TAR) phase occurs first, after which the peripheral drives a SYNC code (0000b for ready, 0101b for short wait, etc.) to signal readiness or insert wait states, followed by the data. The peripheral then drives another TAR to return the bus to the host. This phase can last from 2 to 8 cycles (1 to 4 bytes) for standard transfers, with optional wait states via SYNC if the peripheral requires additional time. In non-ISA modes, such as firmware access, bursts can extend up to 128 bytes, equivalent to 256 clock cycles for data.[1] The transaction concludes with LFRAME# deasserted high after the final TAR. The LPC protocol lacks built-in error detection like CRC; instead, it relies on timeout mechanisms, where the host aborts a transaction if no valid SYNC is received within 3 clocks of undefined codes or if short wait states exceed 8 clocks, prompting software-level retries. Regarding bus arbitration within transactions, the host drives LAD[3:0] and clock signals for the majority of the cycle, while peripherals can request access via the dedicated LDRQ# signal for bus master operations, though such requests are resolved outside the primary transaction flow.[1]Bus Arbitration and Cycles
The Low Pin Count (LPC) bus employs a centralized arbitration mechanism managed by the host controller, which coordinates access among connected peripherals to prevent conflicts on the shared bus lines. Peripherals initiate requests for DMA or bus master operations by asserting their dedicated LDRQ# signal, which encodes a 3-bit channel number and a 1-bit activity status synchronously with the LPC clock (LCLK).[1] The host interprets these requests and grants access using the legacy 8237 DMA controller for standard DMA cycles or dedicated logic for bus master cycles, supporting up to two simultaneous bus masters.[1] This host-centric approach ensures orderly access without distributed arbitration among peripherals. LPC cycles are categorized by type and encoded in the CYCTYPE and DIR fields during the command phase of a transaction, allowing the host to specify the operation over the multiplexed LAD bus. Standard cycle types include I/O read/write cycles, which use a short 16-bit address format transmitted over four LCLK cycles, and memory read/write cycles, which employ an extended 32-bit address over eight LCLK cycles.[1] DMA cycles support 1-, 2-, or 4-byte transfers in read or write direction, initiated via LDRQ# requests and handled in a chained manner similar to ISA compatibility modes.[1] Bus master cycles, also triggered by LDRQ#, enable peripherals to perform I/O or memory accesses of 1, 2, or 4 bytes, with the host facilitating address and data transfer phases.[1] The host controller enforces ordering for concurrent DMA requests following the fixed priorities of the integrated 8237 controller, typically based on channel assignment rather than dynamic IRQ levels.[1] Multiple devices are supported on the LPC bus through address decoding, where each peripheral monitors the ADDR field on the LAD[0:3] lines during the address phase and responds only if the decoded range matches its configured I/O or memory space.[1] This allows for up to 16 devices in typical implementations, limited by the 16-bit I/O address space granularity and proper range allocation to avoid overlaps.[9] Collision detection occurs implicitly through bus monitoring; if multiple devices attempt to drive the LAD lines simultaneously due to address overlap, the host detects contention via invalid SYNC patterns or lack of response and aborts the cycle using LFRAME#.[1] The LPC architecture does not support true peer-to-peer communication, with all cycles routed through the host controller, which multiplexes commands, addresses, and data on the shared LAD bus, thereby limiting concurrency to host-scheduled operations.[1]ISA-Compatible Operations
Memory and I/O Reads and Writes
The Low Pin Count (LPC) interface supports ISA-compatible memory and I/O read and write operations as host-initiated target cycles, designed to emulate traditional ISA bus transactions for seamless integration with legacy software and peripherals. These operations allow the host to access peripherals using the same addressing and data transfer semantics as the ISA bus, without requiring modifications to operating systems or drivers. The protocol ensures synchronous timing while preserving asynchronous ISA behaviors through mechanisms like wait states.[1] Transactions begin with a start phase where the host drives the 4-bit value0000 on the LAD[3:0] bus lines to signal the initiation of a target cycle. In the following cycle type phase (1 clock), bits [3:2] specify the operation: 00 for I/O cycles or 01 for memory cycles, with bit [10] indicating direction (0 for read, 1 for write) and bit reserved as 0. A subsequent SIZE phase (1 clock) encodes the transfer width with LAD[1:0]: 00 for 8-bit, 01 for 16-bit, or 11 for 32-bit (LAD[3:2]=00 reserved). For example, an I/O read uses 0000 in the cycle type phase, while a memory write uses 0110 in the cycle type phase (followed by 0011 in the SIZE phase for 32-bit). The address is then serialized MSB-first over the LAD bus: a 16-bit address for I/O operations (transmitted over 4 clock cycles, supporting up to 64 KB of I/O space) or a 32-bit address for memory operations (over 8 clock cycles, supporting up to 4 GB, though ISA-compatible software typically limits memory accesses to the lower 1 MB or 20-bit address range).[1]
Data transfers support 8-bit (SIZE = 00), 16-bit (SIZE = 01), or 32-bit (SIZE = 11) widths, encoded in the SIZE phase, with byte enables (BE[3:0]) provided during memory writes to allow partial word operations (e.g., enabling specific bytes within a 32-bit transfer). Data is transferred in 4-bit nibbles (LSB-first within each byte) over two clock cycles per byte on LAD[3:0], resulting in 2, 4, or 8 clock cycles for 8-, 16-, or 32-bit transfers, respectively. In a read cycle, the host completes the address phase, followed by a 2-clock turn-around (TAR) period where LAD is tri-stated; the peripheral then asserts SYNC for one clock to signal readiness (inserting wait states if needed) and drives the data during the subsequent phase(s). For a write cycle, the host drives the data immediately after the address (reversing the data flow), with the peripheral responding via SYNC after a TAR to confirm completion, ensuring compatibility with ISA's command/address/data sequencing.[1]
These cycles fully replicate ISA memory and I/O behaviors, including variable latency via SYNC and no protocol-level changes to software interfaces, enabling direct use of existing ISA drivers for peripherals like keyboards, floppy controllers, and serial ports on LPC-equipped systems. Typical timings include 13 clocks for 8-bit I/O reads/writes and 17–21 clocks for 8-bit memory reads/writes, scaling with size and wait states.[1]
DMA Transfers
The Low Pin Count (LPC) interface emulates the Direct Memory Access (DMA) functionality of the Intel 8237 DMA controller to provide ISA-compatible operations for peripherals requiring bulk data transfers to or from system memory without CPU involvement.[1] These transfers are serialized over the LPC bus, effectively mapping the multiple ISA DMA channels to a single logical channel on the host side, while preserving compatibility for legacy devices. Channels 0–3 support 8-bit transfers only, while channels 5–7 support 16-bit transfers (32-bit optional); channel 4 is not supported.[1] DMA operations begin with the peripheral asserting the LDRQ# signal to request access, which the host verifies against programmed channel configurations and grants through internal arbitration logic, potentially referencing bus cycles for prioritization.[1] In the command phase, the transaction starts with0000b (START), followed by the cycle type clock with 1000b for DMA reads (peripheral to memory) or 1010b for DMA writes (memory to peripheral), then a CHANNEL phase (1 clock) where LAD[2:0] specifies the active DMA channel (0-3 or 5-7), and a SIZE phase encoding the width (00 for 8-bit, 01 for 16-bit, 11 for 32-bit).[1] Upon grant, data is transferred in configurable widths of 8, 16, or 32 bits, with the LPC bus's 4-bit (nibble) serialization handling the movement of bytes across multiple clock cycles.[1]
LPC supports Single Transfer, Demand Transfer, Verify Transfer, and Increment Transfer modes, along with auto-initialize for repeated transfers without reprogramming addresses; Block Transfer, Decrement Transfer, and Cascade modes are not supported.[1] Each channel is limited to a maximum transfer size of 64 KB, determined by the 16-bit address and count registers inherited from the 8237 design.[1] Chaining of multiple DMA transfers is enabled via the SYNC command (start code 1001b), which signals the continuation of transfers across sequential bus cycles without releasing the bus.[1]
The nibble-serialized transmission on LPC constrains DMA bandwidth to approximately 3.3 MB/s at the standard 33.3 MHz clock rate, making it suitable for moderate-throughput peripherals such as floppy disk controllers and sound cards rather than high-speed storage.[1]
Interrupt Handling
The Low Pin Count (LPC) interface utilizes the SERIRQ signal to serialize interrupt requests from connected peripherals, multiplexing up to 15 interrupt lines—typically IRQ3 through IRQ15, excluding IRQ13—onto a single shared pin. This approach replaces the multiple dedicated interrupt lines required in the legacy ISA bus, saving approximately 10 pins overall by eliminating the need for separate wiring for each IRQ.[1] The serialization process operates synchronously with the LPC clock (LCLK), using a framed protocol consisting of a start frame, multiple data frames, and a stop frame. A peripheral device initiates an interrupt by driving the SERIRQ line low during the start frame (4 to 8 clock cycles wide, initiated by either the host or device). In the subsequent data frames (3 clock cycles each: sample, recovery, and turn-around phases), the device drives SERIRQ low only in its assigned slot if the corresponding IRQ is asserted; the host identifies the specific IRQ by counting clock cycles from the start frame (e.g., the slot for IRQ6 aligns with the 18th clock cycle, calculated as 3 clocks per frame times the IRQ offset). The sequence concludes with a host-driven stop frame (2 to 3 clock cycles), after which SERIRQ returns to tri-state. The protocol supports both Quiet mode (intermittent frames for power savings) and Continuous mode (periodic scanning).[11][12] Host detection of interrupts occurs through either polling the SERIRQ line during active clock periods or edge detection on signal transitions, ensuring compatibility with existing ISA software stacks without requiring modifications or special drivers. The mechanism preserves ISA interrupt semantics, including support for both level-sensitive and edge-triggered modes, allowing transparent integration with operating systems that expect standard ISA interrupt behavior.[1][13] Due to the time-multiplexed nature of the shared SERIRQ line, interrupt delivery incurs a serialization delay of approximately 1 µs per IRQ in typical configurations (based on full frame scanning at 33 MHz LCLK, where a complete cycle spans up to 51 clocks or ~1.5 µs, though individual slots add minimal incremental latency). Certain system-reserved interrupts, such as IRQ0 (timer), IRQ1 (keyboard), IRQ2 (cascade), IRQ8 (RTC), and IRQ13 (coprocessor error), are not supported over SERIRQ, as they are handled via dedicated hardware paths outside the LPC domain.[11][12]Non-ISA Transactions
Firmware Memory Access
Firmware Memory Access transactions in the Low Pin Count (LPC) interface enable the host to directly read from or write to system firmware storage, such as BIOS or UEFI boot ROMs and flash memory, without incorporating these regions into the full system memory map.[1] This capability was introduced in Revision 1.1 of the LPC specification to support efficient access to firmware during boot processes or updates.[1] These transactions operate as non-ISA cycles, utilizing a dedicated opcode format distinct from standard memory or I/O operations.[1] The transaction begins with a START phase using opcode1101b for reads or 1110b for writes, followed by a 28-bit memory address field (MADDR) transmitted over 7 clock cycles and a size field (MSIZE) specifying the transfer length.[1] Supported sizes include 1 byte (required) and optionally 2, 4, 16, or 128 bytes, with transfers aligned to their size boundaries (e.g., 4-byte transfers on DWORD boundaries).[1] Data is exchanged in burst mode via the LPC's multiplexed LAD[3:0] lines, transferring 4-bit nibbles with the least significant nibble first per byte; for writes, the host provides byte enables to control partial updates, while reads have the peripheral driving data after a turnaround phase.[1] The full cycle includes synchronization (SYNC) and turnaround (TAR) phases to manage timing, allowing up to 256 MB of addressable firmware space across devices.[1]
This mechanism facilitates faster BIOS shadowing—copying firmware into system RAM for quicker execution—and in-system updates by enabling bulk transfers without ISA emulation overhead.[1] However, it lacks inherent security protections, such as error detection or access controls, relying instead on external chipset locks to prevent unauthorized modifications; illegal cycles simply proceed without interruption.[1]