courses

I2C: Surveying a Live Host

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:

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. STM0925 looks 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:

  1. The row labels are two hex digits. 00:, 10:, … 70: match \b[0-9a-f]{2}\b perfectly. Every bus reports the same eight phantom “devices” because those are the row headers, and 00 10 20 30 40 50 60 70 means nothing was found.
  2. UU is not hex. The man page is explicit: UU means 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

⚠️ i2cdetect defaults to SMBus quick-write probing on buses that support it, which writes to every address it touches. -r switches 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, UU is 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 of UU — 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

References

Apple silicon:


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 i915 and xe drivers, and when a dock or external monitor is attached, so always re-run i2cdetect -l rather 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 on i2c-1 was not recovered on this run — 0x2c is the HID-over-I2C convention and the expected value, but confirming it needs either the UU grid position from i2cdetect -y -r 1 or the ACPI _CRS for \_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 second reg cell (0x9C4 for audio parts, 0x2710 for the SD node) is undocumented and is not a bus speed; sd-card@20 carries no compatible string, so the firmware itself declines to name the part; and i2c5 plus the four AppleS5L8960XGPIOIC controllers 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 for t6000, not more ioreg. Do not fill them in by inferring a part from an address.