32 BIT IEEE 1149.1 Utility

JTAG IDCODE Decoder

Decode a 32-bit JTAG identification code into its version, device part number, JEDEC manufacturer identity and mandatory least-significant IDCODE bit. Use it for boundary-scan debugging, FPGA and MCU identification, scan-chain analysis and hardware bring-up.

✓ Version ✓ Part Number ✓ Manufacturer ID ✓ JEDEC Fields ✓ Binary View ✓ IDCODE Validation

JTAG

32-Bit IDCODE Register

● Ready

JTAG IDCODE Value Accepts hexadecimal, decimal or binary input.

Input Format Hexadecimal values can include or omit the 0x prefix.

Standard 32-Bit IDCODE Layout

Version
[31:28]

Part Number
[27:12]

Manufacturer Identity
[11:1]

1
[0]

IEEE 1149.1 IDCODE layout: IDCODE[31:28] is the 4-bit version, IDCODE[27:12] is the 16-bit part number, IDCODE[11:1] is the 11-bit manufacturer identity, and IDCODE[0] must be logic 1 for an IDCODE register value.

JTAG IDCODE Decode Result Decoded

Decoded Identification Code —

32-Bit Hex —

Decimal —

Binary —

IDCODE Validity —

Version —

Part Number —

Part Number Decimal —

Manufacturer Identity —

Manufacturer Binary —

Continuation Code —

Identity Code —

Mandatory Bit 0 —

Version Bits —

Part Bits —

Manufacturer Bits —

Bit Field View —

Calculation Breakdown —

What Is a JTAG IDCODE?

A JTAG IDCODE is a 32-bit identification value associated with the Identification Code Register defined by IEEE 1149.1 boundary-scan architecture. It allows test equipment, debuggers and scan-chain software to obtain basic identification information from a device.

The register provides a version field, device-specific part number and a manufacturer identity derived from the JEDEC manufacturer identification scheme.

JTAG IDCODE Bit Layout

31             28 27                 12 11             1 0
+----------------+----------------------+----------------+---+
|    Version     |     Part Number      | Manufacturer   | 1 |
+----------------+----------------------+----------------+---+

Version:
4 bits

Part Number:
16 bits

Manufacturer Identity:
11 bits

Bit 0:
Always 1 for IDCODE

JTAG IDCODE Version Field

Bits 31 through 28 contain the four-bit version field. A manufacturer can use this value to distinguish revisions of a device while retaining the same basic part-number identity.

IDCODE:
0x12345679

Version =
(IDCODE >> 28) & 0xF

= 0x1

The exact meaning assigned to individual version values is device-specific.

JTAG Part Number Field

Bits 27 through 12 provide a 16-bit part-number field assigned by the device manufacturer.

Part Number =

(IDCODE >> 12)
&
0xFFFF

This number is not necessarily the same as the commercial product name printed on a chip package. Vendor documentation or a device database is normally needed to map the raw part field to a specific product.

JTAG Manufacturer Identity

Bits 11 through 1 contain an 11-bit manufacturer identity based on the JEDEC manufacturer identification scheme.

Manufacturer Identity =

(IDCODE >> 1)
&
0x7FF

This tool reports the full 11-bit value as hexadecimal, decimal and binary so it can be compared with a vendor or JEP106 identification table.

JEDEC Continuation and Identity Fields

The 11-bit manufacturer field can be separated into a four-bit continuation portion and a seven-bit identity portion.

Manufacturer[10:7]:
Continuation code

Manufacturer[6:0]:
Identity code

The raw values are shown separately because manufacturer-name lookup depends on the current JEDEC/JEP106 manufacturer table.

Why JTAG IDCODE Bit 0 Is Always 1

The least significant IDCODE bit is defined as logic one. This characteristic also helps JTAG scan software distinguish an IDCODE value from certain other scan-chain conditions.

Valid IDCODE:

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx1

Bit 0 = 1

If bit 0 is zero, the supplied 32-bit value does not conform to the standard IDCODE register format, even though its other fields can still be extracted for debugging.

JTAG IDCODE Example

Consider this synthetic IDCODE value:

0x12345679

Binary:

0001 0010 0011 0100
0101 0110 0111 1001

The decoder separates the value into its four standard fields rather than treating the entire 32-bit word as a single device number.

IDCODE Field Masks

Field	Bits	Width	Extraction
Version	31:28	4	(IDCODE >> 28) & 0xF
Part Number	27:12	16	(IDCODE >> 12) & 0xFFFF
Manufacturer	11:1	11	(IDCODE >> 1) & 0x7FF
Required LSB	0	1	IDCODE & 1

JTAG IDCODE vs Device ID

A JTAG IDCODE should not automatically be treated as the same value as a microcontroller’s internal device ID, PCI device ID, USB product ID or chip serial number. Those identification mechanisms use different register formats and namespaces.

The JTAG IDCODE specifically follows the boundary-scan identification register format.

JTAG IDCODE vs Serial Number

The 16-bit part field identifies a device design or family according to the manufacturer’s assignment. It does not uniquely identify one physical chip.

If a device provides a unique silicon serial number, that value normally comes from a separate device-specific register or protocol.

IDCODE in a JTAG Scan Chain

Multiple JTAG devices can be connected in a daisy chain. During identification, debug software can shift register data through the chain and inspect the 32-bit values associated with devices that expose IDCODE.

The number, order and instruction state of devices must be understood to correctly associate each shifted value with the corresponding physical device.

IDCODE Instruction

IEEE 1149.1 devices that implement an Identification Code Register provide mechanisms for selecting that register through the JTAG instruction path. Specific reset and default-instruction behavior can depend on the implemented standard requirements and device design.

A raw 32-bit value captured from TDO should therefore be interpreted only after confirming that the scan chain is actually shifting an IDCODE register.

Why a JTAG IDCODE Can Appear Reversed

JTAG shifts data serially, and logic analyzers or debugging software may display shift order differently from the conventional hexadecimal register value. A bit-reversed or byte-reversed capture can therefore look like an invalid IDCODE.

If bit 0 appears incorrect or the fields look unreasonable, verify how the capture tool orders TDI/TDO bits before assuming the device ID is wrong.

JTAG IDCODE Decoder Uses

A decoded IDCODE is useful during FPGA board bring-up, microcontroller debugging, boundary-scan manufacturing tests, OpenOCD configuration, JTAG chain enumeration, BSDL verification, debugger development and reverse engineering of hardware interfaces.

The raw part and manufacturer fields can then be compared with authoritative vendor documentation or JEDEC manufacturer information.

JTAG IDCODE Decoder FAQs

How many bits are in a JTAG IDCODE?

The standard IEEE 1149.1 Identification Code Register contains 32 bits.

Which bits contain the JTAG version?

Version is stored in bits 31 through 28 and is four bits wide.

Where is the JTAG part number?

The 16-bit part-number field occupies bits 27 through 12.

Where is the manufacturer ID in JTAG IDCODE?

The 11-bit manufacturer identity occupies bits 11 through 1.

What should JTAG IDCODE bit 0 contain?

Bit 0 is defined as logic one for the standard IDCODE register format.

How do I extract the JTAG part number?

Right-shift the 32-bit IDCODE by 12 positions and mask the result with 0xFFFF.

How do I extract the manufacturer field?

Right-shift IDCODE by one and mask with 0x7FF to obtain the 11-bit manufacturer identity.

Does the part number identify the exact commercial chip name?

Not necessarily. The field is manufacturer assigned, so vendor documentation or an authoritative device database is required to map it to a product name.

Why does my captured IDCODE have bit 0 equal to zero?

The value may not be an IDCODE register, the scan chain may be in a different instruction state, or the capture may have been displayed in a reversed bit order.

Can this tool automatically identify every chip manufacturer?

The tool decodes the complete JEDEC manufacturer identity field. Mapping every code to a current vendor name requires an up-to-date JEP106 manufacturer table, so the raw identity is preserved rather than guessing a company name.

Decode JTAG Device Identification Codes

Extract the standard IEEE 1149.1 version, part number and JEDEC manufacturer identity from raw JTAG IDCODE values used in boundary-scan, FPGA, MCU and embedded hardware debugging.