I2C: Surveying a Live Host
- Why this matters
- Enumerate before you probe
- The scan, and a parser bug
- A second host: macOS on Apple silicon
- Key takeaways
- References
Why this matters
The I2C page teaches the bus against embedded targets, where you have a schematic, a known part, and one bus to think about. The machine you are reading this on is a harder problem: a modern laptop carries nineteen I2C buses, most of them empty, and the interesting devices are spread across three completely different kinds of controller.
This page is a worked survey of two real hosts. The first is a Lenovo ThinkPad P1 Gen 8, Intel Core Ultra 200H (Arrow Lake-H), running Linux 7.2. The second is a 14-inch MacBook Pro, Apple M1 Max, running macOS — a deliberately non-Linux counterpart, covered in “A second host: macOS on Apple silicon”.
They are here for three reasons. First, they are free targets: you can run every command below on your own laptop tonight without buying hardware or soldering anything. Second, they demonstrate the discipline that matters more than any single tool — enumerate from the kernel before you probe the bus, because probing is the lossy, dangerous, ambiguous half of the job. Third, the pair brackets the range you will meet in practice. The ThinkPad lets you do both halves of the job and shows you what probing adds; the Mac has no probe path at all, so the firmware’s declaration is the only evidence available, and the limits of that are worth feeling directly.
The Linux survey also contains a real mistake, left in deliberately. The first scan of that machine was parsed with a broken script, and the output looked plausible. Section “The scan, and a parser bug” is about how to notice that.
Enumerate before you probe
On an embedded target you probe because you have nothing else. On a running Linux host you have the kernel’s own device model, which is strictly better information: it tells you the driver, the ACPI path, and the bus topology, and it costs nothing and risks nothing.
Start with the bus list:
$ i2cdetect -l
i2c-0 i2c NVIDIA i2c adapter 1 at 1:00.0 I2C adapter
i2c-1 unknown Synopsys DesignWare I2C adapter N/A
i2c-2 unknown Synopsys DesignWare I2C adapter N/A
i2c-3 i2c i915 gmbus dpa I2C adapter
i2c-4 i2c i915 gmbus dpb I2C adapter
...
i2c-12 i2c AUX A/DDI A/PHY A I2C adapter
...
i2c-16 i2c AUX USBC3/DDI TC3/PHY TC3 I2C adapter
i2c-17 i2c AUX USBC4/DDI TC4/PHY TC4 I2C adapter
i2c-18 unknown SMBus I801 adapter at 0000:00:1f.4 N/A
Nineteen buses, in three families:
| Buses | Family | What it is |
|---|---|---|
| i2c-1, i2c-2 | Synopsys DesignWare | The SoC’s general-purpose I2C controllers. Real peripherals live here. |
| i2c-3 … i2c-17 | i915 gmbus / DP AUX | Display plumbing. Every video output gets a bus for EDID and DDC/CI. |
| i2c-18 | Intel i801 SMBus | The platform management bus. Memory module SPD lives here. |
| i2c-0 | NVIDIA | The discrete GPU’s own adapter, same display purpose. |
Cross-reference each one to its PCI function and ACPI path:
$ lspci -nn | grep -iE "smbus|serial bus"
00:15.0 Serial bus controller [0c80]: Intel Corporation Core Ultra 200H/200V Series Processors I2C #0 [8086:7778]
00:19.0 Serial bus controller [0c80]: Intel Corporation Core Ultra 200H/200V Series Processors I2C #4 [8086:7750]
00:1f.4 SMBus [0c05]: Intel Corporation Core Ultra 200H/200V Series Processors SMBus [8086:7722]
00:1f.5 Serial bus controller [0c80]: Intel Corporation Core Ultra 200H/200V Series Processors SPI (flash) Controller [8086:7723]
So i2c-1 is ACPI \_SB.PC00.I2C0 behind PCI 00:15.0, i2c-2 is
\_SB.PC00.I2C4 behind 00:19.0, and i2c-18 is \_SB.PC00.SBUS behind
00:1f.4. Note the fourth line: 00:1f.5 is the SPI flash controller, not I2C.
It matters in a moment.
What the kernel has already claimed
Every I2C client with a bound driver appears under /sys/bus/i2c/devices/ named
<bus>-<addr>:
$ for d in /sys/bus/i2c/devices/*; do
[ -e "$d/name" ] || continue
printf "%-16s name=%-24s driver=%s\n" "$(basename $d)" \
"$(cat $d/name)" "$(basename $(readlink -f $d/driver 2>/dev/null))"
done | grep -v "name=i2c-"
18-0050 name=spd5118 driver=spd5118
i2c-SNSL002D:00 name=SNSL002D:00 driver=i2c_hid_acpi
Two devices, and the names already tell you most of what you need:
-
18-0050— bus 18 (SMBus), address 0x50, driverspd5118. This is the memory module’s SPD hub. It also registers a hwmon node, so the module’s temperature sensor is readable as an ordinary sensor:$ cat /sys/bus/i2c/devices/18-0050/hwmon/hwmon*/temp1_input 4050040.5 °C. The P1 Gen 8 has a single LPDDR5X CAMM2 slot and no soldered memory, which is consistent with finding exactly one SPD device.
-
i2c-SNSL002D:00— a HID-over-I2C device, driveri2c_hid_acpi. Resolve the ACPI path and the HID identity:$ readlink -f /sys/bus/i2c/devices/i2c-SNSL002D:00 /sys/devices/pci0000:00/0000:00:15.0/i2c_designware.0/i2c-1/i2c-SNSL002D:00 $ cat /sys/bus/acpi/devices/SNSL002D:00/path \_SB_.PC00.I2C0.TPD0 $ grep HID_NAME /sys/bus/hid/devices/0018:2C2F:002D.0002/uevent HID_NAME=SNSL002D:00 2C2F:002DTPD0is the touchpad node. Vendor0x2C2Fis Sensel — this is the haptic trackpad, speaking HID over I2C on busi2c-1.
That is the entire set of driver-bound I2C devices on the machine. Note what the
kernel does not give you here: the touchpad’s 7-bit address. ACPI carries it
in the device’s _CRS resource descriptor, which is not exposed in sysfs, so
this is one fact you genuinely do have to probe for.
Ruling things out
Two devices that look like they should be on I2C are not, and checking saves you from chasing them:
$ cat /sys/bus/acpi/devices/STM0925:00/path
\_SB_.TPM_
STM0925 is an STMicroelectronics part and TPMs are often I2C on embedded
boards — but its ACPI path is \_SB.TPM_, not under any I2C controller. On this
platform it is on the SPI controller at 00:1f.5.
$ for i in /sys/bus/iio/devices/*; do echo "$(cat $i/name): $(readlink -f $i)"; done
prox: /sys/devices/pci0000:00/0000:00:14.0/usb3/3-9/3-9:1.4/0003:30C9:00F3.0005/HID-SENSOR-200011.2.auto/iio:device0
prox: /sys/devices/pci0000:00/0000:00:14.0/usb3/3-9/3-9:1.4/0003:30C9:00F3.0005/HID-SENSOR-200011.4.auto/iio:device1
The human-presence sensors are HID sensors behind the USB camera module at
3-9, not I2C peripherals. No Intel ISH driver is loaded on this machine at all.
⚠️ Resist the temptation to infer a bus from a part number or a vendor prefix.
STM0925looks like an I2C sensor and is a SPI TPM. The ACPI path, or the parent directory in sysfs, is the answer; the name never is.
The display buses, without probing
Fifteen of the nineteen buses are display DDC. You can map every one to its
connector and read its EDID without touching /dev/i2c-*, because the kernel
caches EDID in sysfs:
$ for c in /sys/class/drm/card*-*; do
printf "%-16s %-12s ddc=%s\n" "$(basename $c)" "$(cat $c/status)" \
"$(basename $(readlink -f $c/ddc 2>/dev/null))"
done
card0-DP-1 disconnected ddc=i2c-13
card0-DP-2 disconnected ddc=i2c-14
card0-DP-3 disconnected ddc=i2c-15
card0-DP-4 connected ddc=i2c-16
card0-DP-5 disconnected ddc=i2c-17
card0-eDP-1 connected ddc=i2c-12
card0-HDMI-A-1 disconnected ddc=i2c-4
Two connected outputs, so only i2c-12 and i2c-16 should have anything on
them. Confirm what they are:
$ edid-decode /sys/class/drm/card0-DP-4/edid | grep -E "Manufacturer|Product Name"
Manufacturer: RTK
Display Product Name: 'Float2 Pro'
$ edid-decode /sys/class/drm/card0-eDP-1/edid | grep -E "Manufacturer|Product Name"
Manufacturer: AUO
Display Product Name: 'B160UAN06.N '
ddcutil goes one step further and tells you which of them actually answers
DDC/CI, the control protocol at address 0x37:
$ ddcutil detect --brief
Invalid display
I2C bus: /dev/i2c-12
DRM connector: card0-eDP-1
Monitor: AUO:B160UAN06.N:
Display 1
I2C bus: /dev/i2c-16
DRM connector: card0-DP-4
Monitor: RTK:Float2 Pro:
The external monitor answers. The internal panel is reported “Invalid display” because eDP panels have an EDID but generally do not implement DDC/CI — there is no brightness register to write, the backlight is driven by the GPU instead. This is the expected result for a laptop, not a fault.
The scan, and a parser bug
Everything above came from sysfs. The one remaining question — the touchpad’s address, plus any device with no driver bound to it — needs an actual bus scan, which needs root.
The first attempt used this loop:
# BROKEN -- do not copy
out=$(i2cdetect -y -r "$b" 2>/dev/null | tail -n +2 \
| grep -oE "\b[0-9a-f]{2}\b" | tr "\n" " ")
and produced output that looked entirely reasonable:
i2c-0 NVIDIA i2c adapter 1 at 1:00.0 FOUND: 00 10 20 30 40 50 60 70
i2c-1 Synopsys DesignWare I2C adapter FOUND: 00 10 20 30 40 50 60 70
i2c-2 Synopsys DesignWare I2C adapter FOUND: 00 10 1b 20 30 30 34 40 50 60 70
i2c-3 i915 gmbus dpa FOUND: 00 10 20 30 40 50 60 70
...
i2c-12 AUX A/DDI A/PHY A FOUND: 00 08 10 20 30 40 50 50 60 70
i2c-16 AUX USBC3/DDI TC3/PHY TC3 FOUND: 00 10 20 30 30 37 40 4a 4b 50 50 60 70
i2c-18 SMBus I801 adapter at 0000:00:1f.4 FOUND: 00 10 20 30 35 40 44 48 4a 4b 50 60 70
Nineteen buses all reporting devices, including nine buses whose connectors are disconnected. That is the tell. Here is the raw format the regex was fed:
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
...
70: -- -- -- -- -- -- -- --
Two bugs, in opposite directions:
- The row labels are two hex digits.
00:,10:, …70:match\b[0-9a-f]{2}\bperfectly. Every bus reports the same eight phantom “devices” because those are the row headers, and00 10 20 30 40 50 60 70means nothing was found. UUis not hex. The man page is explicit:UUmeans probing was skipped because a driver already holds that address, and “strongly suggests that there is a chip at this address.” A regex matching[0-9a-f]{2}discards exactly the devices you already confirmed exist. Both known devices — the touchpad and the SPD hub — vanished from the output.
The output is still recoverable, because the labels appear in a fixed order and a
real device at a label address shows up as a duplicate. i2c-16’s 30 30 is
“row label 30, then a device at 0x30”, and 50 50 is the same for 0x50. The
fixed loop strips labels by position instead of by pattern, and keeps UU:
for b in $(i2cdetect -l | awk '{print $1}' | sed 's/i2c-//' | sort -n); do
name=$(cat "/sys/bus/i2c/devices/i2c-$b/name" 2>/dev/null)
out=$(i2cdetect -y -r "$b" 2>/dev/null | tail -n +2 \
| sed 's/^[0-9a-f]\{2\}: //' \
| tr ' ' '\n' | grep -vxE -- '--|' | tr '\n' ' ')
printf "i2c-%-2s %-36s %s\n" "$b" "$name" "${out:-(empty)}"
done
⚠️
i2cdetectdefaults to SMBus quick-write probing on buses that support it, which writes to every address it touches.-rswitches to read-byte probing, which is the gentler choice and the one used here. Neither is free: read-byte probing can still confuse write-only devices, and the i801 SMBus on a running laptop is shared with firmware. Scan a system you can afford to reboot.
Corrected results
| Bus | Adapter | Responding addresses |
|---|---|---|
| i2c-0 | NVIDIA adapter 1 | none |
| i2c-1 | DesignWare, I2C0 |
touchpad, UU (address not recovered — see below) |
| i2c-2 | DesignWare, I2C4 |
0x1b, 0x30, 0x34 — unidentified |
| i2c-3 … i2c-11 | i915 gmbus dpa–tc4 | none |
| i2c-12 | AUX A — internal panel | 0x08, 0x50 |
| i2c-13, 14, 15, 17 | AUX B, USBC1/2/4 | none |
| i2c-16 | AUX USBC3 — external monitor | 0x30, 0x37, 0x4a, 0x4b, 0x50 |
| i2c-18 | i801 SMBus | 0x35, 0x44, 0x48, 0x4a, 0x4b, and UU at 0x50 |
Reading it bus by bus:
i2c-16, the external monitor. This is a textbook E-DDC address set.
0x50 is the EDID EEPROM, 0x30 is the segment pointer used to reach EDID
blocks past the first two, and 0x37 is DDC/CI — the same 0x37 ddcutil
spoke to above. 0x4a and 0x4b are not DDC addresses and are unidentified;
the display is a USB-C portable monitor with a Realtek controller, so a retimer
or the controller’s own management interface are both plausible, and neither is
confirmed.
i2c-12, the internal panel. 0x50 is the panel’s EDID, matching the
edid-decode output. 0x08 is unexplained. It is worth treating with
suspicion rather than cataloguing: I2C-over-AUX is a tunnelled transport, and
i2cdetect’s address-only probes are exactly the transaction type that AUX
bridges are documented to mishandle.
i2c-18, the SMBus. UU at 0x50 is the spd5118 hub already identified
from sysfs. The cluster at 0x48, 0x4a, 0x4b falls inside the DDR5 PMIC range
— JESD300-5B.01 assigns PMICs the 7-bit addresses 1001 HID[2:0], i.e.
0x48–0x4F — and an independent scan on another Arrow Lake system reports PMICs
at 0x48 and 0x4a, so this reading is well supported though not vendor-confirmed.
0x35 and 0x44 are unidentified. The i801 bus is shared with platform
firmware and the embedded controller, which is the most likely source, but this
page will not guess further.
i2c-2 is the interesting one. Three addresses answered on a bus that has no ACPI children and no bound drivers at all — the bus the earlier enumeration concluded was unpopulated. Either there is hardware here that Linux never enumerates (a different SKU’s touchscreen controller, left populated), or these are probe artifacts on a floating bus. Both are ordinary outcomes and the scan alone cannot distinguish them.
Recovering the touchpad address
The scan above does not actually answer the question it was run for. The broken
parser discarded UU entirely, and the corrected one prints UU as a token
without a position — so neither tells you which address on i2c-1 the touchpad
driver holds. This value is still unresolved on this machine.
Getting it requires reading the raw grid by eye, because a UU cell is
identified by its row and column, and that position is never printed as a number
anywhere:
$ sudo i2cdetect -y -r 1
In the output, find the UU cell: its row label gives the high nibble and its
column header the low nibble, so a UU in row 20: under column c is address
0x2c. The HID-over-I2C convention for Lenovo touchpads is 0x2c, which is the
value to expect here, but expecting is not confirming — the authoritative source
is the _CRS resource descriptor in ACPI for \_SB.PC00.I2C0.TPD0, which sysfs
does not expose and which needs a DSDT dump:
$ sudo cp /sys/firmware/acpi/tables/DSDT /tmp/dsdt.dat
$ iasl -d /tmp/dsdt.dat && grep -A6 "Device (TPD0)" /tmp/dsdt.dsl
That is the exercise: the grid position tells you what the kernel claimed, and the DSDT tells you what the firmware declared. They should agree.
A second host: macOS on Apple silicon
The ThinkPad survey had both halves of the job available — enumerate from the kernel, then probe to fill the two gaps enumeration left. This second host is worth walking through because it has only the first half. There is no probe path at all, which makes it both a cleaner demonstration of the thesis and a sharper lesson in what enumeration cannot tell you.
The machine is a 14-inch MacBook Pro, MacBookPro18,4, Apple M1 Max (SoC
codename t6000), running Darwin 27.2.0.
There is nothing to probe with
Start by establishing the negative result, because it determines everything that follows:
$ ls /dev/i2c*
zsh: no matches found: /dev/i2c*
$ which i2cdetect i2cget i2ctransfer
i2cdetect not found
i2cget not found
i2ctransfer not found
macOS exposes no I2C character devices and ships no i2c-tools. Installing
them would not help: i2cdetect talks to /dev/i2c-N, and there is no such
node to create. The kernel-side AppleARMIICUserClient exists — you will see it
referenced below — but it is not a documented or generally reachable interface,
and reaching it means writing a kext against private APIs.
So on this host you cannot send an address byte and watch for an ACK. Every fact below is an assertion made by Apple’s firmware, not an observation of the bus.
Enumerating from the IORegistry
The equivalent of /sys/bus/i2c/devices/ on macOS is the IORegistry, and the
equivalent of the ACPI DSDT is the Apple Device Tree (ADT), which the firmware
hands to the kernel and which appears as the IODeviceTree plane. One command
dumps every I2C client:
$ ioreg -p IODeviceTree -c AppleARMIICDevice -r -l -w0
AppleARMIICDevice is the class for an I2C client node; AppleARMIODevice with
an i2c@ name is a controller. Note Apple’s spelling: IIC, not I2C, in every
class name. Listing the controllers first:
$ ioreg -p IODeviceTree -w0 | grep -E "i2c[0-9]@"
| +-o i2c0@9B040000 <class AppleARMIODevice, ...>
| +-o i2c1@9B044000 <class AppleARMIODevice, ...>
| +-o i2c2@9B048000 <class AppleARMIODevice, ...>
| +-o i2c3@9B04C000 <class AppleARMIODevice, ...>
| +-o i2c4@9B050000 <class AppleARMIODevice, ...>
| +-o i2c5@9B054000 <class AppleARMIODevice, ...>
Six controllers at 0x4000 intervals from 0x9B040000, all with the same
compatible property and all bound to the same driver class:
$ ioreg -p IODeviceTree -r -l -w0 -n i2c3@9B04C000 | grep compatible
| "compatible" = <"i2c,t6000","i2c,s5l8940x","iic,soft">
Three strings, read most-specific-first, and the middle one is the interesting
part. s5l8940x is the Apple A5 — this I2C block has been carried essentially
unchanged since the iPhone 4S, and it descends from P.A. Semi’s PWRficient
design, which Apple acquired in 2008. That is why Linux drives it with a
platform variant of the PA Semi driver, i2c-pasemi-platform.c, and why the
Linux binding spells the same controller apple,t6000-i2c with an apple,i2c
fallback. Six buses against the ThinkPad’s nineteen, and no display buses in the
set at all — DisplayPort AUX on this SoC is handled by separate dcp/dptx
blocks, not by an exposed I2C adapter.
The devices
Nine I2C clients, which is the whole set the firmware declares:
| Bus | MMIO base | Addr | Device tree name | compatible |
Part |
|---|---|---|---|---|---|
| i2c0 | 0x9B040000 | 0x6B | hpmBusManager |
usbc,manager |
USB-C PD controller manager |
| i2c1 | 0x9B044000 | 0x38 | audio-speaker |
audio-control,sn012776 |
TI SN012776 smart amp — left woofer 1 |
| i2c1 | 0x39 | audio-speaker-left-woofer-2 |
audio-control,sn012776 |
left woofer 2 | |
| i2c1 | 0x3A | audio-speaker-left-tweeter |
audio-control,sn012776 |
left tweeter | |
| i2c2 | 0x9B048000 | 0x4B | audio-codec-output |
audio-control,cs42l84 |
Cirrus Logic CS42L84 headphone codec |
| i2c3 | 0x9B04C000 | 0x3B | audio-speaker-right-woofer-1 |
audio-control,sn012776 |
right woofer 1 |
| i2c3 | 0x3C | audio-speaker-right-woofer-2 |
audio-control,sn012776 |
right woofer 2 | |
| i2c3 | 0x3D | audio-speaker-right-tweeter |
audio-control,sn012776 |
right tweeter | |
| i2c4 | 0x9B050000 | 0x20 | sd-card |
(none) | SD slot side-channel — unidentified |
| i2c5 | 0x9B054000 | — | — | — | controller present, no devices declared |
The address comes from the node name suffix and from the first cell of reg:
$ ioreg -p IODeviceTree -r -l -w0 -n i2c3@9B04C000 | grep -E '\+-o|"reg"|"compatible"'
+-o audio-speaker-right-woofer-1@3B <class AppleARMIICDevice, ...>
"reg" = <3b000000c40900000000000000000000>
"compatible" = <"audio-control,sn012776">
reg is little-endian: 3b000000 is the 7-bit address 0x3B, matching the
@3B in the name. The second cell is 0x9C4 (2500) for every audio part and
0x2710 (10000) for the SD node. It is not the bus speed — neither value is a
legal I2C clock — and Apple documents none of this, so this page records the
numbers and declines to guess at them.
Reading it bus by bus:
Six speaker amps, split across two buses. sn012776 is a TI part that is
near-compatible with the TAS2764; Linux drives it with an extended tas2764
driver. Six amps for a six-speaker array, deliberately split left-channel on
i2c1 and right-channel on i2c3 so the two halves do not contend for bus
bandwidth. Note the naming gap: i2c1 has audio-speaker@38 where symmetry wants
audio-speaker-left-woofer-1, and i2c3 names its counterpart explicitly. The
addresses (0x38–0x3A, 0x3B–0x3D) are a contiguous block assigned by position.
One codec. cs42l84 at 0x4B on its own bus is the Cirrus Logic part driving
the headphone jack — jack detection and the analog output path.
The USB-C manager, and a bus behind a bus. The node at i2c0:0x6B is not a port controller itself. Expanding it:
$ ioreg -p IODeviceTree -r -l -w0 -n hpmBusManager@6B | grep -E '\+-o|"compatible"'
+-o hpmBusManager@6B <class AppleARMIICDevice, ...>
"compatible" = <"usbc,manager">
+-o hpm0 <class AppleHPMBusDevice, ...> "compatible" = <"usbc,cd3217">
+-o hpm1 <class AppleHPMBusDevice, ...> "compatible" = <"usbc,cd3217">
+-o hpm2 <class AppleHPMBusDevice, ...> "compatible" = <"usbc,cd3217">
+-o hpm5 <class AppleHPMBusDevice, ...> "compatible" = <"usbc,cd3217">
Four usbc,cd3217 devices — Apple’s CD321x, a variant of TI’s TPS6598x USB-C
port controller, which Linux drives with tipd. Four of them matches this
model’s three Thunderbolt 4 ports plus MagSafe. The important structural point
is that they have no address on i2c0: they are AppleHPMBusDevice, not
AppleARMIICDevice, sitting on a secondary bus that the manager owns. Scanning
i2c0 would find 0x6B and nothing else, and would tell you nothing about the four
devices behind it. The non-obvious index (hpm0/1/2/5, no 3 or 4) is firmware
numbering and should not be read as two missing devices.
The empty bus and the odd one. i2c5 has a controller with no declared
children. On the ThinkPad an empty bus was a question you could answer by
scanning; here it is simply unanswerable. And sd-card@20 has a reg and a
name but no compatible string at all, so even the firmware is not naming a
part. The name says it relates to the SD slot — a level shifter or card-detect
side-channel is plausible — but nothing here confirms it.
What this enumeration cannot see
Worth stating explicitly, because the gaps are different from the Linux ones:
$ ioreg -c AppleGPIOICController -r -w0 | grep -E '\+-o'
+-o AppleS5L8960XGPIOIC
+-o AppleS5L8960XGPIOIC
+-o AppleS5L8960XGPIOIC
+-o AppleS5L8960XGPIOIC
Four bit-banged GPIO I2C controllers are instantiated and declare no child devices. Whether they are genuinely unused or carry devices the ADT does not describe is not determinable from here.
More importantly, this is not every I2C-ish thing in the laptop. The nine devices above are what hangs off the SoC’s six I2C blocks. Plenty of sensors you would expect on a laptop — the thermal and power sensors behind the SMC, the always-on processor’s sensor set, the display panel’s own control interface — do not appear, because they are reached over other transports entirely. A survey that stopped here and concluded “this laptop has nine I2C devices” would be describing the ADT, not the hardware.
⚠️ Compare the epistemic status of the two surveys. On Linux,
UUis the strongest evidence of a device: a driver successfully bound and now holds the address, and you can corroborate it by probing elsewhere. On macOS every row in the table above is the moral equivalent ofUU— a device the system believes in — but with no probe available anywhere, there is nothing to corroborate it against. A node the firmware omits is invisible and will stay invisible. The declared bus and the real bus are different things, and this host only ever shows you the first.
For the course’s purposes that asymmetry is the point. i2cdetect -y 1 on a Pi
or a BeagleBone walks the address space and reports what actually acknowledged;
ioreg reports what somebody wrote in a device tree. When you are assessing an
unfamiliar target, the second is where you start and the first is what settles
it — and on hosts like this one, you do not get to settle it without hardware.
Key takeaways
- On a running Linux host, enumerate from
/sys/bus/i2c/devices/,/sys/bus/acpi/devices/*/path, and/sys/class/drm/*/ddcbefore you probe. It is free, risk-free, and gives you the driver and ACPI path that a scan never will. - The kernel’s view is incomplete in one specific way: it shows no device without
a bound driver, and it does not expose a client’s address from ACPI
_CRS. Those two gaps are the only legitimate reasons to scan. i2cdetectoutput has three cell values and a parser must handle all of them: hex means found-and-unclaimed,--means nothing answered, andUUmeans probing was skipped because a driver holds it — the strongest evidence of a device, and the easiest to accidentally drop.i2cdetect’s row labels are valid hex. Anygrepfor hex digits over its output will invent eight devices per bus. If every bus reports the same set, you are reading row headers.- A
UUaddress can only be read from the grid by column position; it is not printed as a number anywhere. - Display buses are the majority of a laptop’s I2C and the most predictable:
0x50 EDID, 0x30 E-DDC segment pointer, 0x37 DDC/CI. Connectors reporting
disconnectedshould be silent, and on this machine all nine were. - Addresses answering on a bus with no ACPI children, and single odd hits on AUX-tunnelled buses, are as likely to be probe artifacts as hardware. Record them as unidentified; do not invent a part for them.
-r(read-byte) probing is gentler than the default quick-write, which genuinely writes to every address it touches. On a shared platform bus like the i801, scan only a system you can afford to reboot.- The enumerate-first habit transfers to platforms where
i2c-toolsdoes not exist; only the command changes. Linux has/sys/bus/i2c/devices/, macOS hasioreg -p IODeviceTree -c AppleARMIICDevice, and both are reading a structure the firmware supplied — sysfs via ACPI, the IORegistry via the Apple Device Tree. - Some hosts give you no probe path at all. macOS has no
/dev/i2c-*and no way to send an address byte, so the declared bus is the only bus you can see. Enumeration is then not the safe first step, it is the whole survey — and anything the firmware omits stays invisible. - Read
compatiblestrings most-specific-first; they carry history. The M1 Max’s<"i2c,t6000","i2c,s5l8940x">dates the controller to the Apple A5 and points at its P.A. Semi ancestry, which is why Linux drives it with a PA Semi variant. - A device can sit behind another device rather than on the bus. The Mac’s USB-C port controllers hang off a bus manager at 0x6B and have no address on the parent bus, so a scan of that bus would find the manager and miss all four.
- Neither host’s enumeration is a complete hardware inventory. Sensors on the ThinkPad’s camera module are USB; the Mac’s thermal and power sensors are behind the SMC and AOP. “Everything on the I2C buses” and “everything in the laptop” are different questions.
References
- i2c-tools
i2cdetect(8)manual, definitions of--,UU, and probing modes — https://manpages.debian.org/jessie/i2c-tools/i2cdetect.8.en.html - Linux
i2c-toolssource — https://git.kernel.org/pub/scm/utils/i2c-tools/i2c-tools.git/ - NXP UM10204, I2C-bus specification and user manual (Rev. 7.0, October 2021) — https://www.pololu.com/file/0J435/UM10204.pdf
- NetBSD
ddcreg.h, DDC address constants (EDID 0x50, segment pointer 0x30) — https://nxr.netbsd.org/xref/src/sys/dev/i2c/ddcreg.h - Linux patch refusing DDC/CI (0x37) transfers on dw-hdmi’s internal controller — https://patchwork.kernel.org/patch/11049583/
ddcutildocumentation — https://www.ddcutil.com/ddr5-shellkit, DDR5 SPD/PMIC/TS addressing over SMBus — https://github.com/peterhu/ddr5-shellkit- Bus Pirate, DDR5 SDRAM module I2C notes — https://docs.buspirate.com/docs/devices/ddr5/
- Linux patch adding (LP)DDR5 types to
i2c_register_spd()— https://patchew.org/linux/20240426220748.28184-2-pmenzel@molgen.mpg.de/ - ABLIC S-34HTS08AB, DDR5 SPD EEPROM with hub and temperature sensor — https://www.ablic.com/en/doc/datasheet/dimm_serial_eeprom_spd/S34HTS08AB_E.pdf
- Lenovo ThinkPad P1 Gen 8 features and specifications — https://download.lenovo.com/manual/thinkpad_p1_gen8_t1g_gen8/user_guide/en/Features_and_specifications.html
Apple silicon:
- Sven Peter, “Add Apple M1 support to PASemi i2c driver” (v2), establishing the P.A. Semi ancestry of the Apple I2C block — https://lore.kernel.org/lkml/YWP71c8cXlE3PcIo@kunai/T/
- “dt-bindings: i2c: Add Apple I2C controller bindings”, the
apple,i2c/apple,t6000-i2ccompatibles — https://lkml.rescloud.iu.edu/2110.1/00832.html - Sven Peter, “usb: typec: tipd: Add Apple M1 support”, describing Apple CD321x as a TI TPS6598x variant and its SMC-side secondary I2C bus — https://lore.kernel.org/lkml/YUce5EcD7Pys5Z4s@sunset/T/
- James Calligeros et al., “ASoC: tas2764: Extend driver to SN012776” — the speaker amp in Apple’s 2021 laptops, near-compatible with the TAS2764 — https://lkml.iu.edu/hypermail/linux/kernel/2502.3/08065.html
- Asahi Linux documentation, Apple Device Tree and SoC peripheral notes — https://asahilinux.org/docs/
Related course pages: I2C · SPI · Hardware Communications Protocols · Dumping flash · Schedule
🛠️ Maintenance note: this survey is a snapshot of two machines. The Linux half is a ThinkPad P1 Gen 8 on Linux 7.2.11, and its bus numbering is not stable. Bus indices depend on probe order and will renumber across kernel versions, between the
i915andxedrivers, and when a dock or external monitor is attached, so always re-runi2cdetect -lrather than trusting the numbers in the table. The unidentified addresses (i2c-2’s 0x1b/0x30/0x34, i2c-16’s 0x4a/0x4b, i2c-18’s 0x35/0x44, i2c-12’s 0x08) are left open deliberately and are good student exercises; if any are ever pinned down, name the part and cite a datasheet rather than inferring from the address alone. The touchpad’s address oni2c-1was not recovered on this run — 0x2c is the HID-over-I2C convention and the expected value, but confirming it needs either theUUgrid position fromi2cdetect -y -r 1or the ACPI_CRSfor\_SB.PC00.I2C0.TPD0, and neither has been captured here yet.The macOS half is a
MacBookPro18,4(M1 Max) on Darwin 27.2.0. Its bus indices are stable, because they are firmware-assigned names rather than probe-order numbers, but everything in that section is a firmware assertion that no probe on this platform can check — if a later macOS release changes what the ADT declares, the table changes with it and nothing will flag the difference. Three things there are deliberately left open and make good student exercises: the secondregcell (0x9C4 for audio parts, 0x2710 for the SD node) is undocumented and is not a bus speed;sd-card@20carries nocompatiblestring, so the firmware itself declines to name the part; and i2c5 plus the fourAppleS5L8960XGPIOICcontrollers declare no children at all, which on this host is simply unanswerable. Resolving any of them likely means cross-referencing the Asahi Linux device trees fort6000, not moreioreg. Do not fill them in by inferring a part from an address.