Skip to contentSkip to conversation

i2c: imc-skylake: add Intel Skylake-X iMC SMBus adapter

PATCH Superseded Simone Chifari 4 participants 7 messages Jul 28 – Sep 30

Subsystems (2)

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore
#0 lore raw

v3 cover i2c: imc-skylake: add Intel Skylake-X iMC SMBus adapter

The integrated memory controller of Intel Skylake-X and Cascade Lake-X processors contains an SMBus engine wired to the DDR4 DIMMs. This driver exposes its two channels as standard Linux I2C adapters, so that DDR4 SPD EEPROMs and DIMM thermal sensors can be read with i2c-tools, decode-dimms and lm-sensors.

v2 was posted as i2c-imc-x299 and received no replies:

https://lore.kernel.org/linux-i2c/[email protected]/

Correction to v2
~~~~~~~~~~~~~~~~
v2 claimed that firmware filters CF8/CFC config writes to this function and that the registers can only be reached through the ECAM window. That claim was wrong and I am retracting it.

It was never tested directly. The only evidence behind it was the boot log line "PCI: Using configuration type 1", which says which accessor the kernel uses and nothing about a write failing. Measured on the same board:

  # setpci -s 16:1e.5 9c.L=20085002    # read SPD 0x50, register 0x02
  # setpci -s 16:1e.5 9c.L
  20005002                             # GO consumed
  # setpci -s 16:1e.5 a8.L
  0000500c                             # READ_DONE, no error
  # setpci -s 16:1e.5 b4.L
  0000000c                             # SPD byte 2: DDR4 type code

The command written through CF8/CFC is executed and returns correct data, and MSR_SMI_COUNT does not move across it. This driver therefore uses pci_read_config_dword() and pci_write_config_dword() like any other driver. There is no ECAM mapping, no MCFG parsing and no PCI-core change in this series any more.

Firmware arbitration
~~~~~~~~~~~~~~~~~~~~
This is the reason no iMC SMBus driver has ever been merged, and this patch does not solve it either. It does make the condition detectable.

Andy Lutomirski's original i2c_imc put it plainly: a BMC, the memory controller's power management, and possibly SMM all like to touch this bus, and Intel defined no way to arbitrate between them. That driver already had a module parameter called allow_unsafe_access. Stefan Schaeckeler's 2020 Broadwell rewrite went further and stopped the PCU's TSOD polling for the duration of a transfer (write 0 to TSODCNTL, wait 10 ms for in-flight transactions to drain, restore afterwards), because on Broadwell the original driver's consistency check tripped about every 30 minutes.

https://lwn.net/Articles/635898/
https://lore.kernel.org/linux-i2c/[email protected]/

So this driver:

- keeps the default-off allow_unsafe_access gate, deliberately the same

    name as the original;
  - serializes both channels under one mutex and waits for the whole engine
    to be idle before touching any register;
  - saves the command state of both channels, clears TSOD_ACTIVE for the
    duration of the transfer, and restores both afterwards;

- after every transfer compares the command registers against what it left in them and fails the transfer with -EAGAIN if anything else changed. This is the check the original driver had, and it is what makes an unarbitrated system detectable rather than silently wrong;
- reads the command word back and requires it to be the one just written, because the done bits are latched. With the driver unloaded and nothing running, STATUS on the test system reads 0x0000300c:
READ_DONE and WRITE_DONE both still set from an earlier transaction. Without the check, a command word that never reaches the register is indistinguishable from a completed transfer and the caller receives the previous transaction's data. The engine only ever clears GO, so that is the single permitted difference between the two words.

- refuses to bind when the memory controller is polling the DIMM thermal sensors itself. Intel documents SMBCNTL on the iMC channel function (device 10 and 12, function 0, offsets 0xe88 and 0xe98) in the Xeon Processor Scalable Family datasheet volume 2, reference 614073, section 3.1.9. Its SMB_TSOD_POLL_EN bit is documented as mutually exclusive with SPD command access, so it answers directly whether the engine is in use. On the test system all four channels read 0xac000000: polling disabled, TSOD_PRESENT mask empty, which also explains why no jc42 device appears at 0x18-0x1f.

This is deliberately weaker than what the Broadwell-E driver did. That one switched the polling off for the duration of a transfer. Reading the bit and declining is a smaller claim on hardware the driver does not own, and it needs no write to a firmware-configured register. It covers the memory controller only; SMM and a BMC remain out of reach, which is what the opt-in is for.

Relation to prior work
~~~~~~~~~~~~~~~~~~~~~~
There is no iMC I2C driver in mainline. Lutomirski's i2c-imc was an RFC; the 2020 resend and github.com/Linux4/i2c-imc are out of tree. Neither can be extended to cover this part: the device ID (0x2085 vs 0x3ca8/0x6fa8) and the register layout (0x9C-0xB8 vs 0x180-0x188) differ. A separate file is cleaner than a hw_data table.

The register encoding was cross-checked against an independent Windows implementation for the same engine, which predates this work:

https://github.com/namazso/PawnIO.Modules/blob/c975ca1d1b8a9c7473a175fa1ca24d83b6cbc8f3/SmbusIntelSkylakeIMC.p

It also implements SMBus BYTE through a pointer-select bit, without saying which bit. That bit is 18 here. The datasheet gave it away: SMBCMD on the iMC channel functions places PNTR_SEL immediately above WORD_ACCESS, and word access on the PCU function is bit 17.

Bit 18 is the only part of this driver that rests on an undocumented encoding, so it is worth saying exactly what was measured rather than asserting it works. With the bit set on a read, eight consecutive transfers to an SPD EEPROM returned bytes 0x01 through 0x08 in order, matching an ordinary dump of the same range. That is the auto-increment of a Receive Byte; a transfer that still named a register would have returned the same byte eight times. With the bit set on a write, a Send Byte to the DDR4 page-select addresses moves the 256-byte window: byte 0x00 stops reading as the JEDEC 0x23 after selecting page 1 and returns to it after selecting page 0.

ee1004 consequently binds, and decode-dimms reads all four DIMMs on this system with both SPD CRCs valid on each. jc42 binds where a sensor is populated. i2cdetect scans in read mode.

With Receive Byte in place the driver can also do what the other SMBus host drivers do and call i2c_register_spd() per adapter, so the SPD EEPROMs are instantiated at probe rather than by hand. The helper counts the populated slots from DMI and probes upwards from 0x50, leaving alone any address that does not answer; each channel carries half the DIMMs and the scan is per adapter, so each finds its own. Nothing else is instantiated, jc42 included: there is no firmware description of these buses and this driver does not scan for anything but the SPDs.

I used the write_disable variant. This part is DDR4 only, where the two are equivalent - the distinction gates spd5118 on DDR5 - and between two equivalent calls the one that does not read as "this driver enables SPD writes" seemed the better thing to leave in a memory-bus driver. Happy to switch to write_enable for consistency with i801 and piix4 if you prefer the convention.

SMBus Quick is still not implemented, and not only because the engine has no obvious encoding for it. A write to the 0x30-0x37 range is how an EE1004 SPD is write-protected, permanently on many modules. An adapter whose bus is the memory bus should not advertise a probe that writes.

Changes since v2
~~~~~~~~~~~~~~~~
- Retract the CF8/CFC claim; use the ordinary config accessors. The driver no longer maps anything.
- Rename i2c-imc-x299 to i2c-imc-skylake; the engine is in the CPU, not the chipset.
- Add the default-off allow_unsafe_access gate.
- Wait for both channels to be idle before touching the data latch.
- Preserve and restore command and TSOD state for both channels.
- Validate READ_DONE, WRITE_DONE and the hardware error state.
- Detect interference from another master and report it as -EAGAIN.
- Read the command word back and require it to be the one written.
- Add bounded command-toggle recovery for a stuck BUSY state.
- Add WORD_DATA support with the hardware byte ordering.
- Reject I2C_M_TEN explicitly and validate transfer direction.
- Use the i2c core's suspended-adapter mechanism instead of a private flag and a non-standard errno.
- Use devm_mutex_init() and devm-managed adapters; drop the unnecessary pci_enable_device(); return -ENODEV rather than -EPERM from the default-off gate, which was logging a driver-core error on every boot.
- Add Documentation/i2c/busses/i2c-imc-skylake.rst.
- Drop the ACPI dependency.
- Refuse to bind when the iMC reports TSOD polling enabled.
- Correct the claim that BYTE_DATA and WORD_DATA cover ee1004: they do not, ee1004 also needs Receive Byte and Send Byte.
- Implement both, on the pointer-select bit, so ee1004 binds and decode-dimms works.
- Instantiate the SPD EEPROMs with i2c_register_spd() instead of leaving it to the user.

Validation
~~~~~~~~~~
- In-tree build, W=1, x86_64 GCC and arm64 Clang COMPILE_TEST: no diagnostics.
- checkpatch.pl --strict: clean.
- Sparse with __CHECK_ENDIAN__: clean.
- Hardware test on one Intel Core i9-10900X (Cascade Lake-X) system with four DDR4 DIMMs: both adapters, four SPD EEPROMs, BYTE_DATA, WORD_DATA byte order, Receive Byte tracking the EEPROM pointer, Send Byte moving the SPD page and putting it back, ENXIO for an absent device, 100 concurrent reads per channel, the default-off gate, and 20 unload/reload cycles: 19 checks, 0 failures, no kernel warning or oops, no interference reported, every command word confirmed in the register.
- i2c_register_spd() instantiated ee1004 on all four populated SPD addresses at probe, two per channel, and claimed none of the empty ones. decode-dimms then decoded all four modules, each with the CRC of bytes 0-125 and of bytes 128-253 valid. The part number reads out of page 1, so the page select is exercised end to end. The four module serial numbers were identical before and after every experiment in this series.
- Engine registers sampled every 2 s for one hour with the driver
unloaded: 1791 samples, 0 changes. No firmware activity while the system is up.
- Suspend and resume, s2idle and S3, with continuous traffic on both
adapters: transfers recover and nothing complains. Across S3 the firmware demonstrably drives the engine. Both channels, sampled immediately before suspend and immediately after resume:

DATA 0x2000b600 -> 0x20005000
STATUS 0x0000500c -> 0x00005004

The command word came back addressing SPD 0x50 for a read, and the status went from both done bits latched to READ_DONE alone. Nothing in Linux issued that: the adapter was marked suspended and userspace was frozen. This is consistent with firmware reading SPD during memory training on resume. It is the only direct observation of a second master on this engine I have, and it is the concrete reason the driver restores command state per transfer and compares it afterwards.
- SMBCNTL on all four iMC channels reads 0xac000000: TSOD polling disabled, TSOD_PRESENT empty.
- Writes validated end to end against a populated device: a 12-write frame to an LED controller at 0x27, across both channels, every write acknowledged, no NACK, and the device applied the result. A byte write to an unpopulated address returns -ENXIO with the engine reporting the address NACK. No SPD was written at any point, and the four SPD EEPROMs were verified present with valid CRCs before and after.

Still missing: an independent Tested-by, ideally on Skylake-X rather than Cascade Lake-X.

One note on the register interface, since a reader with the datasheet will ask. That document describes an SMBus interface on the iMC channel function at 0xe80-0xe9c, with a different encoding from the one this driver uses on PCU function 5 at 0x9c-0xb8; it does not describe function 5 at all, covering device 30 functions 0 and 2 only. I tried the documented path on this system: issuing SMBCMD with CMD_TRIGGER sets SMB_RDO and clears SMB_BUSY, but returns 0x00 for a populated DIMM at 0x50, for a second one at 0x52, and for an empty slot at 0x57 alike, with SMB_SBE never set. An interface that cannot tell a populated slot from an empty one is not reaching the bus here, while the path this driver uses returns the correct SPD contents and a NACK for the empty slot. I may well be missing a setup step; if someone knows what it is, I would rather use the documented interface.

Tool assistance
~~~~~~~~~~~~~~~
Per Documentation/process/generated-content.rst: this work was developed with an AI coding assistant, run interactively rather than autonomously.

- What: Claude Code, model claude-opus-5.
- Where: it contributed to the transaction state machine, the .rst documentation, the commit message and this cover letter. The register decoding is mine.
- How it was used: iteratively, one reviewed change at a time, in response to specific requests, not from a single generating prompt. A representative request is "the done bits are latched; show me how a command that is never accepted can be mistaken for a completed one, and make that case detectable", which produced imc_engine_responded(). It also designed the measurement that retracted the CF8/CFC claim above, after asking why that claim had never been tested directly.
- Testing: every revision was built with W=1, checked with checkpatch --strict and sparse, and tested on the hardware by me.

I have reviewed all of it, I understand it, and I take responsibility for it.

Simone Chifari (1):
i2c: imc-skylake: add Intel Skylake-X iMC SMBus adapter

 Documentation/i2c/busses/i2c-imc-skylake.rst | 178 +++++
 Documentation/i2c/busses/index.rst           |   1 +
 MAINTAINERS                                  |   7 +
 drivers/i2c/busses/Kconfig                   |  27 +
 drivers/i2c/busses/Makefile                  |   1 +
 drivers/i2c/busses/i2c-imc-skylake.c         | 734 +++++++++++++++++++
 6 files changed, 948 insertions(+)
 create mode 100644 Documentation/i2c/busses/i2c-imc-skylake.rst
 create mode 100644 drivers/i2c/busses/i2c-imc-skylake.c

base-commit: 8cd9520d35a6c38db6567e97dd93b1f11f185dc6

Signature · 1 line
2.43.0
#1 lore raw

PATCH v3 1/1 i2c: imc-skylake: add Intel Skylake-X iMC SMBus adapter

The integrated memory controller of Intel Skylake-X and Cascade Lake-X processors contains an SMBus engine wired to the DDR4 DIMMs. It reaches the SPD EEPROMs at 0x50-0x57 and the thermal sensors at 0x18-0x1f, on two independent channels. Expose the two channels as standard I2C adapters so i2c-tools, decode-dimms and lm-sensors can use them.

The engine is driven through the config space of the PCU function 8086:2085, at offsets 0x9C-0xB8, with the ordinary config accessors.

It has no arbitration mechanism. SMM, a BMC and the memory controller's own closed-loop thermal throttling can drive the same registers, and the PCI ID does not tell the driver whether any of them is active, so keep the driver default-off behind allow_unsafe_access, as the earlier iMC drivers for Sandy Bridge-EP and Broadwell-E did.

Refuse to bind outright when the memory controller is polling the DIMM thermal sensors itself. The Intel Xeon Processor Scalable Family datasheet volume 2 (reference 614073, section 3.1.9) documents SMBCNTL on the iMC channel function, device 10 and 12 function 0, at offsets 0xe88 and 0xe98. Its SMB_TSOD_POLL_EN bit is documented as mutually exclusive with SPD command access, so it answers directly whether the engine is already in use. Read it on every channel at probe. This is weaker than the Broadwell-E driver, which switched the polling off for the duration of a transfer; declining is a smaller claim on hardware the driver does not own and needs no write to a firmware-configured register. It covers the memory controller only, not SMM or a BMC.

On top of that gate, serialize both channels under one mutex, wait for the whole engine to be idle before touching any register, save the command state of both channels and clear TSOD_ACTIVE for the duration of the transfer, and restore both afterwards. Then compare the command registers against what the driver left in them and fail the transfer with -EAGAIN when anything else changed: without that check a second master using the engine is silently wrong rather than merely unsupported.

The completion bits are latched and no way to clear them has been found. With the driver unloaded and nothing running, STATUS on the test system reads 0x0000300c, both READ_DONE and WRITE_DONE still set from an earlier transaction. A command word that never reaches the register is therefore indistinguishable from a completed transfer: the stale word has GO already clear, STATUS already shows a DONE, and the caller receives the previous transaction's data as valid. Read the command word back and require it to be the one just written. The engine only ever clears GO, so that is the single permitted difference.

Support SMBus Receive Byte and Send Byte, BYTE_DATA and WORD_DATA, and reject 10-bit addressing and unsupported protocols explicitly. That covers jc42 and ee1004, so decode-dimms reads the whole 512-byte DDR4 SPD including the fields on page 1.

Receive Byte and Send Byte need a command word that puts no register byte on the bus, which the engine encodes in bit 18. That bit is not documented for this function, and it is the only undocumented encoding this driver relies on, so it was pinned down rather than assumed. SMBCMD on the iMC channel function places PNTR_SEL immediately above WORD_ACCESS, and word access on the PCU function is bit 17. With bit 18 set on a read, eight consecutive transfers to an SPD EEPROM returned bytes 0x01 through 0x08 in order, matching an ordinary dump of the same range: that is the auto-increment of a Receive Byte, and a transfer still naming a register would have returned the same byte eight times. With it set on a write, a Send Byte to the DDR4 page-select addresses moves the 256-byte window and moves it back.

With Receive Byte available, instantiate the SPD EEPROMs the way the other SMBus host drivers do, with i2c_register_spd() per adapter, rather than leaving it to the user. The helper counts the populated slots from DMI and probes upwards from 0x50, so it claims no address that does not answer; each channel carries half the DIMMs and the scan is per adapter, so each finds its own. Nothing else is instantiated, jc42 included:
there is no firmware description of these buses and this driver does not scan for anything but the SPDs.

The write_disable variant is used deliberately. This part is DDR4 only, where the two are equivalent - the distinction gates spd5118 on DDR5 - and of two equivalent calls the one that does not read as "this driver enables SPD writes" is the better name to leave in a driver whose bus is the memory bus.

Do not implement SMBus Quick. Besides having no obvious encoding here, a write into the 0x30-0x37 range is how an EE1004 SPD is write-protected, permanently on many modules. An adapter whose bus is the memory bus should not advertise a probe that writes; i2cdetect scans these buses in read mode.

Assisted-by Claude-Code:claude-opus-5 checkpatch sparse
---
 Documentation/i2c/busses/i2c-imc-skylake.rst | 178 +++++
 Documentation/i2c/busses/index.rst           |   1 +
 MAINTAINERS                                  |   7 +
 drivers/i2c/busses/Kconfig                   |  27 +
 drivers/i2c/busses/Makefile                  |   1 +
 drivers/i2c/busses/i2c-imc-skylake.c         | 734 +++++++++++++++++++
 6 files changed, 948 insertions(+)
 create mode 100644 Documentation/i2c/busses/i2c-imc-skylake.rst
 create mode 100644 drivers/i2c/busses/i2c-imc-skylake.c
Documentation/i2c/busses/i2c-imc-skylake.rst new file +178 -0
new file mode 100644
index 000000000..a1babbb7d
@@ -0,0 +1,178 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+=============================
+Kernel driver i2c-imc-skylake
+=============================
+
+Supported adapters:
+  * Intel Skylake-X / Cascade Lake-X integrated memory controller (iMC)
+    SMBus engine, PCU function 8086:2085 (socket LGA 2066, platform X299)
+
+Author: Simone Chifari <[email protected]>
+
+
+Description
+-----------
+
+The integrated memory controller of Intel Skylake-X and Cascade Lake-X
+processors contains an SMBus engine wired to the DDR4 DIMMs.  It reaches the
+SPD EEPROMs (0x50-0x57) and the thermal sensors (TSOD, 0x18-0x1f) of the
+installed modules, plus whatever else a particular module carries on those
+lines.
+
+The engine has two independent channels.  DIMM slots 1 and 2 are on channel 0,
+slots 3 and 4 on channel 1, so the driver registers two i2c adapters::
+
+    $ i2cdetect -l | grep iMC
+    i2c-6   smbus   iMC SMBus Skylake-X channel 0   SMBus adapter
+    i2c-7   smbus   iMC SMBus Skylake-X channel 1   SMBus adapter
+
+Both channels share one hardware engine, so the driver serializes every
+transaction across both adapters.
+
+
+This driver is not enabled by default
+-------------------------------------
+
+The SMBus engine has no arbitration mechanism.  System Management Mode, a BMC,
+and the memory controller's own closed-loop thermal throttling (CLTT) can all
+drive the same registers, and nothing in the PCI ID tells the driver whether
+any of them is doing so on a given system.  Two masters using the engine at the
+same time can send a transaction to the wrong address or return the wrong data.
+
+The driver therefore refuses to bind unless the operator opts in::
+
+    modprobe i2c-imc-skylake allow_unsafe_access=1
+
+Do this only on a system where concurrent firmware access has been excluded.
+Desktop and HEDT boards have no BMC, but CLTT may still be enabled by the
+firmware.
+
+The driver reduces, but cannot remove, the risk.
+
+At probe it reads SMBCNTL on every iMC channel function (device 10 and 12,
+function 0; offsets 0xe88 and 0xe98, documented in the Intel Xeon Processor
+Scalable Family datasheet volume 2, reference 614073, section 3.1.9).
+``SMB_TSOD_POLL_EN`` in that register says whether the memory controller is
+polling the DIMM thermal sensors on its own, which Intel documents as mutually
+exclusive with SPD command access.  If the bit is set on any channel the driver
+refuses to bind: the engine is not ours to drive.  This covers the memory
+controller, not SMM or a BMC, which remain the reason for the opt-in.
+
+Per transfer:
+
+  * every transaction waits for both channels to report idle before it
+    touches any register;
+  * the previous command state of both channels is saved, the TSOD-active
+    state is cleared for the duration of the transfer, and both are restored
+    afterwards;
+  * after each transfer the command registers are compared against what the
+    driver left in them.  A difference means another master used the engine,
+    and the transfer is failed with ``-EAGAIN`` rather than reported as
+    successful.
+
+The last check is what makes an unarbitrated system detectable: if the log
+shows
+
+  ``chN command changed under us (...): another master is using the engine``
+
+then firmware is using the engine and the driver should not be loaded on that
+system.
+
+
+Config space access
+-------------------
+
+The engine's registers live at config space offsets 0x9C-0xB8 of the PCU
+function and are reached with the ordinary ``pci_read_config_dword()`` and
+``pci_write_config_dword()``.  Nothing special is required.
+
+Supported transactions
+----------------------
+
+The driver implements SMBus Receive Byte and Send Byte, Read/Write Byte Data
+and Read/Write Word Data.
+
+That covers ``jc42`` (TSOD) and ``ee1004``, so ``decode-dimms`` reads the whole
+512-byte DDR4 SPD, including the manufacturer and part-number fields that live
+on page 1.
+
+Receive Byte and Send Byte need a command word that puts no register byte on
+the bus.  The engine encodes that in bit 18, which is not documented for this
+function.  It was found by noting that the interface Intel does document for
+the iMC channel functions (SMBCMD, datasheet reference 614073, section 3.1.8)
+places ``PNTR_SEL`` immediately above ``WORD_ACCESS``, and that word access
+here is bit 17.  With the bit set, consecutive reads of an SPD EEPROM return
+consecutive bytes, which is the auto-increment behaviour of a Receive Byte and
+cannot be produced by a transfer that names a register.
+
+SMBus Quick is not implemented.  ``i2cdetect`` therefore has to be run in
+read mode::
+
+    $ i2cdetect -y -r 6
+         0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
+    20: -- -- -- -- -- -- -- 27 -- -- -- -- -- -- -- --
+    30: 30 31 -- -- 34 35 36 -- -- -- -- -- -- -- -- --
+    50: 50 -- 52 -- -- -- -- -- -- -- -- -- -- -- -- --
+
+Not advertising Quick is deliberate as well as accurate.  A write to the
+0x30-0x37 range is how an EE1004 SPD is write-protected, permanently on many
+modules, so an adapter on a memory bus should not offer probing that writes.
+
+Block transfers are not implemented.  The engine has block primitives, but no
+device on this bus needs them.
+
+Word transfers use the standard SMBus byte order, so ``jc42`` reading through
+``i2c_smbus_read_word_swapped()`` gets the value it expects.
+
+
+Instantiating clients
+---------------------
+
+SPD EEPROMs are instantiated at probe with ``i2c_register_spd()``, like the
+other SMBus host drivers.  It counts the populated slots from DMI and probes
+from 0x50 upwards, so an address that does not answer is left alone.  Each
+channel carries half the DIMMs and the scan runs per adapter, so each finds
+its own::
+
+    i2c i2c-6: Successfully instantiated SPD at 0x50
+    ee1004 6-0050: 512 byte EE1004-compliant SPD EEPROM, read-only
+
+``decode-dimms`` therefore works with no manual step.
+
+Nothing else is instantiated: there is no firmware description of these buses
+and the driver does not scan for anything but the SPDs.  ``jc42`` has to be
+added by hand where a thermal sensor is populated::
+
+    # echo jc42 0x18 > /sys/bus/i2c/devices/i2c-6/new_device
+
+Whether one is populated is visible in ``SMBCNTL.TSOD_PRESENT``; on the
+development system that mask is empty and no ``jc42`` binds.
+
+Two things about the SPDs are worth knowing on this bus.
+
+A DDR4 SPD is a 512-byte array reached through a 256-byte window, and which
+half is visible is a property of the bus, not of the transfer.  ``ee1004``
+selects a page when it needs one and leaves it selected, so a raw ``i2cget``
+issued afterwards may be looking at page 1.  Select page 0 explicitly before
+reading SPD by hand::
+
+    # i2cset -y 6 0x36 0x00 c
+
+And ``ee1004`` owns those addresses once bound, so userspace cannot reach them
+through ``/dev/i2c-*`` any more.  This is ordinary I2C behaviour, but it is
+worth stating here because the userspace tools that motivate this driver share
+the bus with the SPDs.  Read the SPD through the driver instead::
+
+    $ cat /sys/bus/i2c/drivers/ee1004/6-0050/eeprom | hexdump -C
+
+or, if an address really is needed raw, release it::
+
+    # echo 0x50 > /sys/bus/i2c/devices/i2c-6/delete_device
+
+Module parameters
+-----------------
+
+allow_unsafe_access
+  Bool, read-only after load, defaults to false.  The driver does not bind
+  unless this is set.  See the section above.
Documentation/i2c/busses/index.rst +1 -0
index 5e4077b08..2d503d59d 100644
@@ -15,6 +15,7 @@ I2C Bus Drivers
    i2c-amd-mp2
    i2c-diolan-u2c
    i2c-i801
+   i2c-imc-skylake
    i2c-ismt
    i2c-mlxcpld
    i2c-nforce2
MAINTAINERS +7 -0
index c8d4b913f..17bc737b5 100644
@@ -13265,6 +13265,13 @@ S:	Maintained
 F:	drivers/platform/x86/intel/int3472/
 F:	include/linux/platform_data/x86/int3472.h
 
+INTEL SKYLAKE-X IMC SMBUS DRIVER
+M:	Simone Chifari <[email protected]>
+L:	[email protected]
+S:	Maintained
+F:	Documentation/i2c/busses/i2c-imc-skylake.rst
+F:	drivers/i2c/busses/i2c-imc-skylake.c
+
 INTEL SPEED SELECT TECHNOLOGY
 M:	Srinivas Pandruvada <[email protected]>
 L:	[email protected]
drivers/i2c/busses/Kconfig +27 -0
index 8c935f867..deafd7890 100644
@@ -180,6 +180,33 @@ config I2C_I801_MUX
 	  Optional support for multiplexed SMBUS on certain systems with
 	  more than 8 memory slots.
 
+config I2C_IMC_SKYLAKE
+	tristate "Intel Skylake-X iMC SMBus adapter"
+	depends on PCI && (X86_64 || COMPILE_TEST)
+	select I2C_SMBUS
+	help
+	  Say Y here if you want kernel support for the integrated memory
+	  controller (iMC) SMBus engine found in Intel Skylake-X / Cascade
+	  Lake-X processors (socket LGA 2066, platform X299, PCU function
+	  8086:2085).
+
+	  Two I2C adapters are registered, one per hardware SMBus channel,
+	  allowing access to DDR4 DIMM SPD EEPROMs (0x50-0x57) and thermal
+	  sensors from userspace via standard i2c-tools and lm-sensors.
+	  SPD EEPROMs are instantiated automatically from DMI, so decode-dimms
+	  works without any manual step.
+
+	  Firmware, SMM, a BMC or CLTT may drive the same engine and no
+	  generic arbitration mechanism is known.  The driver therefore
+	  refuses to bind unless the allow_unsafe_access module parameter
+	  is enabled.  See Documentation/i2c/busses/i2c-imc-skylake.rst.
+
+	  If unsure, say N.  This driver is only useful on Intel X299 desktop
+	  / HEDT systems with the Skylake-X or Cascade Lake-X CPU.
+
+	  This driver can also be built as a module.  If so, the module
+	  will be called i2c-imc-skylake.
+
 config I2C_ISCH
 	tristate "Intel SCH SMBus 1.0"
 	depends on PCI && HAS_IOPORT
drivers/i2c/busses/Makefile +1 -0
index 547123ab3..3f45fb8ca 100644
@@ -17,6 +17,7 @@ obj-$(CONFIG_I2C_AMD756)	+= i2c-amd756.o
 obj-$(CONFIG_I2C_AMD8111)	+= i2c-amd8111.o
 obj-$(CONFIG_I2C_CHT_WC)	+= i2c-cht-wc.o
 obj-$(CONFIG_I2C_I801)		+= i2c-i801.o
+obj-$(CONFIG_I2C_IMC_SKYLAKE)	+= i2c-imc-skylake.o
 obj-$(CONFIG_I2C_ISCH)		+= i2c-isch.o
 obj-$(CONFIG_I2C_ISMT)		+= i2c-ismt.o
 obj-$(CONFIG_I2C_NFORCE2)	+= i2c-nforce2.o
drivers/i2c/busses/i2c-imc-skylake.c new file +734 -0

734 lines not on this page · raw message

Signature · 1 line
2.43.0
#2 lore raw
kernel test robot noticed the following build warnings:

Hi Simone,

kernel test robot noticed the following build warnings:

[auto build test WARNING on 8cd9520d35a6c38db6567e97dd93b1f11f185dc6]

url:    https://github.com/intel-lab-lkp/linux/commits/Simone-Chifari/i2c-imc-skylake-add-Intel-Skylake-X-iMC-SMBus-adapter/20260729-033603
base:   8cd9520d35a6c38db6567e97dd93b1f11f185dc6
patch link:    https://lore.kernel.org/r/20260728122423.358416-2-simone.chifari%40gmail.com
patch subject: [PATCH v3 1/1] i2c: imc-skylake: add Intel Skylake-X iMC SMBus adapter
config: um-randconfig-r133-20260729 (https://download.01.org/0day-ci/archive/20260729/[email protected]/config)
compiler: clang version 17.0.6 (https://github.com/llvm/llvm-project 6009708b4367171ccdbf4b5905cb6a803753fe18)
sparse: v0.6.5-rc1
reproduce (this is a W=1 build): (https://download.01.org/0day-ci/archive/20260729/[email protected]/reproduce)

If you fix the issue in a separate patch/commit (i.e. not just a new version of the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <[email protected]>
| Closes: https://lore.kernel.org/oe-kbuild-all/[email protected]/

All warnings (new ones prefixed by >>):

In file included from drivers/i2c/busses/i2c-imc-skylake.c:49:
In file included from include/linux/i2c.h:19:
In file included from include/linux/regulator/consumer.h:35:
In file included from include/linux/suspend.h:5:
In file included from include/linux/swap.h:9:
In file included from include/linux/memcontrol.h:13:
In file included from include/linux/cgroup.h:27:
In file included from include/linux/kernel_stat.h:8:
In file included from include/linux/interrupt.h:11:
In file included from include/linux/hardirq.h:11:
In file included from arch/um/include/asm/hardirq.h:24:
In file included from include/linux/irq.h:20:
In file included from include/linux/io.h:12:
In file included from arch/um/include/asm/io.h:24:
include/asm-generic/io.h:1209:55: warning: performing pointer arithmetic on a null pointer has undefined behavior [-Wnull-pointer-arithmetic]
1209 | return (port > MMIO_UPPER_LIMIT) ? NULL : PCI_IOBASE + port;
| ~~~~~~~~~~ ^

>> drivers/i2c/busses/i2c-imc-skylake.c:331:28: warning: implicit conversion from 'unsigned long' to 'u32' (aka 'unsigned int') changes value from 18446744073171697664 to 3757113344 [-Wconstant-conversion]
     331 |                 u32 mask = i == c->idx ? ~COMMAND_OUR_BITS : ~0U;
         |                     ~~~~                 ^~~~~~~~~~~~~~~~~

2 warnings generated.

vim +331 drivers/i2c/busses/i2c-imc-skylake.c

317
318 /*
319 * Detect a second master. Compare the command registers against what this
320 * driver left in them: for the channel it drove, only the bits it does not own;
321 * for the other channel, all of them. A difference means firmware, a BMC or
322 * CLTT touched the engine while the transfer was in flight, so the result
323 * cannot be trusted.
324 */
325 static int imc_check_interference(struct imc_smbus *s, const struct imc_chan *c,
326 const struct imc_xfer_state *state)
327 {
328 int i;
329
330 for (i = 0; i < ARRAY_SIZE(imc_chans); i++) {

 > 331			u32 mask = i == c->idx ? ~COMMAND_OUR_BITS : ~0U;

332 u32 expect = state->command[i] & COMMAND_KEEP_MASK;
333 u32 now = imc_reg(s, imc_chans[i].data);
334
335 if (!((now ^ expect) & mask))
336 continue;
337
338 dev_warn_ratelimited(s->dev,
339 "ch%d command changed under us (0x%08x -> 0x%08x): another master is using the engine\n",
340 i, expect, now);
341 return -EAGAIN;
342 }
343
344 return 0;
345 }
346

--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki

maintainer
#3 lore raw

Hi Simone,

Quoted 3 lines · kernel test robot

Hi Simone,

kernel test robot noticed the following build warnings:

Please, be aware that with a test robot failure or warning i don't look at the driver, but I expect a new version coming.

Thanks,
Andi

#4 lore raw

Hi Andi,

Quoted 2 lines · Andi Shyti

Please, be aware that with a test robot failure or warning i don't look at the driver, but I expect a new version coming.

Thanks for the heads-up. The warning is fixed in v4, which I posted on 2026-08-08 as a new thread:

    https://lore.kernel.org/linux-i2c/[email protected]/

The interference check now casts the complement to u32 ((u32)~COMMAND_OUR_BITS), and the changelog carries the Reported-by and Closes tags for this report.

If v4 no longer applies to i2c/i2c-host, let me know and I will send a v5 rebased on it.

Thanks,
Simone

Il giorno mar 29 set 2026 alle ore 23:14 Andi Shyti <[email protected]> ha scritto:

Quoted 13 lines

Hi Simone,

Quoted 3 lines · kernel test robot

Hi Simone,

kernel test robot noticed the following build warnings:

Please, be aware that with a test robot failure or warning i don't look at the driver, but I expect a new version coming.

Thanks,
Andi

Tested-by on v3 1/1
#5 lore raw
In reply to Simone Chifari

Hi Simone, Andi,

I tested this driver end-to-end on real hardware. Code as published at
https://github.com/systempal/i2c-imc-skylake (matching the v3/v4 series; the v4 rework did not change anything relevant to this test).

Hardware: ASUS ROG STRIX X299-XE GAMING, Intel Core i9-7980XE (Skylake-X, PCU function 8086:2085 at 0000:16:1e.5), 8x G.Skill F4-3600C18-16GTZR (all slots populated), Linux Mint 22, kernel 7.0.0-30-generic.

Results:

- Both adapters register: "iMC SMBus Skylake-X channel 0/1" as /dev/i2c-1 and /dev/i2c-2.
- All eight ee1004 SPD EEPROM clients instantiate at 0x36/0x37 and 0x50-0x53 on both channels; the sysfs eeprom dumps are correct (byte 0 = 0x23, JEDEC manufacturer G.Skill).
- SMBCNTL at the 16:00.0 iMC channel function reads 0x00000000 (TSOD_POLL_EN clear), so the TSOD-polling check passes. On this BIOS allow_unsafe_access=1 is required ("firmware/SMM arbitration is unknown").
- Through the driver's adapters, OpenRGB's ENE SMBus DRAM detector finds all eight RGB controllers at SMBus addresses 0x70-0x73 (four per channel), and every mode (Static, Direct per-LED, Breathing, Flashing, Spectrum Cycle, Rainbow, Chase, Random Flicker) works end-to-end. This is the first working Linux RAM-RGB path on this platform.

One observation that may be worth adding to the driver documentation:
the RGB controller ICs on G.Skill Trident Z RGB DIMMs answer at SMBus addresses 0x70-0x73 on this bus (4 per channel), not the 0x39-0x3D range that older OpenRGB-era documentation assumed.

Thanks,
Adamyno

author Tested-by Adamyno
#6 lore raw
Quoted 3 lines · Adamyno

I tested this driver end-to-end on real hardware. Code as published at
https://github.com/systempal/i2c-imc-skylake (matching the v3/v4 series; the v4 rework did not change anything relevant to this test).

Hi Adamyno,

thanks for testing, and for the detailed report. It is the first report from a board other than mine, and it will go into the next cover letter as such: a second vendor and BIOS, SMBCNTL reading 0 where mine reads 0xac000000, ee1004 on all eight modules, and the RGB write traffic through both adapters.

For the record, since the tag lands on the v3 thread: the GitHub main you tested has the same transfer path as v4 and only adds shutdown handling that is not part of the series. I will carry

in the next revision, unless v4 is applied as is.

If you have time for more, two read-only measurements would help with the question this series still leaves open: whether the firmware uses the engine behind the driver's back. The numbers in the v4 cover letter come from my board only, and yours has a different BIOS. Both scripts are in tools/ of the same repository (see tools/README.md) and only read config space:

  # OpenRGB closed, driver unloaded: anything that moves is firmware
  sudo modprobe -r i2c_imc_skylake
  sudo ./tools/watch-engine.sh --seconds 3600
  sudo ./tools/dump-pcu-config.sh --settle 10

The raw output is what matters, and it would be credited to you in the cover letter. A suspend/resume cycle during the watch-engine hour would make it even more useful.

Quoted 4 lines

One observation that may be worth adding to the driver documentation:
the RGB controller ICs on G.Skill Trident Z RGB DIMMs answer at SMBus addresses 0x70-0x73 on this bus (4 per channel), not the 0x39-0x3D range that older OpenRGB-era documentation assumed.

Useful to know, but I think it fits OpenRGB's documentation better than the driver's: the driver does not know about the devices behind it, and ENE controllers can be re-addressed at runtime (OpenRGB's detector does exactly that), so the address depends on the modules and on the firmware or software that set them up.

Thanks,
Simone