test(hw): add RX data-capture smoke test to every hw test

``assert_jesd_links_data`` verifies the JESD204 link reports
``Link status: DATA``, but that only says the transport reached the
data state at link-up — drivers can probe cleanly, IIO devices can
appear, the link can show DATA, and yet no samples actually arrive
through the AXI-DMA path.  Silent "drivers look OK, buffer comes
back all-zero / constant" is the single most common CI failure
mode and the existing assertions miss it completely.

Add ``assert_rx_capture_valid(device, n_samples=2**12, min_std=1.0,
context="")`` to ``test/hw/hw_helpers.py``.  Takes any pyadi-iio
RX-capable instance, configures the buffer size, calls ``rx()``,
and asserts:

- Every channel delivered exactly ``n_samples``.
- At least one channel is not all-zero (DMA actually transferred
  bytes).
- At least one channel's ``|std|`` is ``>= min_std`` LSBs (samples
  vary; a latched converter or a disconnected FIFO does not clear
  this even at one LSB).

Wire it into every hw test that already has IIO verification,
using the chip-appropriate pyadi-iio class:

- ``test_ad9081_zcu102_xsa_hw.py``     → ``adi.ad9081``
- ``test_ad9081_zcu102_system_hw.py``  → ``adi.ad9081``
- ``test_adrv9009_zcu102_hw.py``       → ``adi.adrv9009``
- ``test_adrv9371_zc706_hw.py``        → ``adi.ad9371``
- ``test_fmcdaq3_vcu118_hw.py``        → ``adi.daq3``

Each site pulls the IP address out of the existing
``open_iio_context(shell)`` return tuple so no extra boot traffic
is needed.  The capture happens after ``assert_jesd_links_data``
so a link-down regression still surfaces on the clearer JESD check
rather than an opaque "samples look wrong" failure.

Author: tfcollins

test/hw/hw_helpers.py

@@ -521,6 +521,75 @@ def assert_jesd_links_data(
     return rx_status, tx_status
 
 
+def assert_rx_capture_valid(
+    device,
+    n_samples: int = 2**12,
+    min_std: float = 1.0,
+    context: str = "",
+) -> list:
+    """Capture ``n_samples`` from a pyadi-iio RX device and verify data is flowing.
+
+    Covers the "IIO device probed but no samples actually arrive" failure
+    mode: the JESD204 link reports DATA, drivers probe cleanly, IIO
+    devices appear, but the DMA / JESD transport / clock path silently
+    stops delivering samples.  ``rx()`` returns a buffer, but every
+    sample is zero, or every sample is the same value.
+
+    Asserts:
+
+    - Every channel delivers exactly ``n_samples`` samples.
+    - At least one channel is not all-zero (DMA actually transferred
+      bytes).
+    - At least one channel's |std| is ``>= min_std`` LSBs (samples
+      actually vary — noise floor alone clears this threshold easily,
+      but a latched converter does not).
+
+    Args:
+        device: pyadi-iio Rx-capable instance (e.g. ``adi.ad9081``,
+            ``adi.adrv9009``, ``adi.daq3``).
+        n_samples: buffer depth for the capture.
+        min_std: minimum |std| across all channels, in raw-LSB units.
+        context: tag prepended to assertion-failure messages.
+
+    Returns:
+        The per-channel captured arrays, as returned by ``device.rx()``
+        but always wrapped into a list of ``numpy.ndarray``.
+    """
+    import numpy as np
+
+    device.rx_buffer_size = n_samples
+    data = device.rx()
+    channels = data if isinstance(data, list) else [data]
+    channels = [np.asarray(ch) for ch in channels]
+
+    suffix = f" ({context})" if context else ""
+    assert channels, f"rx() returned no channels{suffix}"
+    for i, ch in enumerate(channels):
+        assert ch.size == n_samples, (
+            f"rx channel {i}{suffix}: got {ch.size} samples, expected "
+            f"{n_samples}"
+        )
+
+    nonzero = [i for i, ch in enumerate(channels) if np.any(ch != 0)]
+    assert nonzero, (
+        f"All {len(channels)} rx channel(s) returned zero samples{suffix}"
+        " — JESD/DMA/clock path is likely stalled."
+    )
+
+    stds = [float(np.abs(ch).std()) for ch in channels]
+    max_std = max(stds)
+    assert max_std >= min_std, (
+        f"All rx channels latched to a constant value{suffix} "
+        f"(max |std|={max_std:.3g} < {min_std}) — data path stuck."
+    )
+
+    print(
+        f"rx capture{suffix}: {len(channels)} channel(s), {n_samples} samples, "
+        f"non-zero={nonzero}, max |std|={max_std:.2f}"
+    )
+    return channels
+
+
 def _kernel_cache_key(platform_arch: str, config_path: Path) -> str:
     """Return a short sha256 over *platform_arch* and the config file bytes."""
     import hashlib

test/hw/test_ad9081_zcu102_system_hw.py

@@ -47,6 +47,7 @@
     assert_jesd_links_data,
     assert_no_kernel_faults,
     assert_no_probe_errors,
+    assert_rx_capture_valid,
     collect_dmesg,
     compile_dts_to_dtb,
     deploy_and_boot,
@@ -272,7 +273,7 @@ def test_ad9081_zcu102_system_hw(board, built_kernel_image_zynqmp, tmp_path):
         "AD9081 probe signature was not found in kernel dmesg output"
     )
 
-    ctx, _ = open_iio_context(shell)
+    ctx, ip_address = open_iio_context(shell)
 
     found = [d.name for d in ctx.devices]
     assert "hmc7044" in found, (
@@ -294,3 +295,8 @@ def test_ad9081_zcu102_system_hw(board, built_kernel_image_zynqmp, tmp_path):
     )
     print(f"$ cat .../84a90000.axi?jesd204?rx/status\n{rx_status}")
     print(f"$ cat .../84b90000.axi?jesd204?tx/status\n{tx_status}")
+
+    # Data-path smoke test: capture a real buffer and verify samples flow.
+    import adi  # noqa: PLC0415
+    ad9081 = adi.ad9081(uri=f"ip:{ip_address}")
+    assert_rx_capture_valid(ad9081, n_samples=2**12, context="ad9081 system")

test/hw/test_ad9081_zcu102_xsa_hw.py

@@ -36,6 +36,7 @@
     assert_jesd_links_data,
     assert_no_kernel_faults,
     assert_no_probe_errors,
+    assert_rx_capture_valid,
     collect_dmesg,
     compile_dts_to_dtb,
     deploy_and_boot,
@@ -190,7 +191,7 @@ def test_ad9081_zcu102_xsa_hw(board, built_kernel_image_zynqmp, tmp_path):
         "AD9081 probe signature was not found in kernel dmesg output"
     )
 
-    ctx, _ = open_iio_context(shell)
+    ctx, ip_address = open_iio_context(shell)
 
     found = {d.name for d in ctx.devices if d.name}
     assert "hmc7044" in found, (
@@ -212,3 +213,8 @@ def test_ad9081_zcu102_xsa_hw(board, built_kernel_image_zynqmp, tmp_path):
     )
     print(f"$ cat .../84a90000.axi?jesd204?rx/status\n{rx_status}")
     print(f"$ cat .../84b90000.axi?jesd204?tx/status\n{tx_status}")
+
+    # Data-path smoke test: capture a real buffer and verify samples flow.
+    import adi  # noqa: PLC0415
+    ad9081 = adi.ad9081(uri=f"ip:{ip_address}")
+    assert_rx_capture_valid(ad9081, n_samples=2**12, context="ad9081 xsa")

test/hw/test_adrv9009_zcu102_hw.py

@@ -39,6 +39,7 @@
     assert_jesd_links_data,
     assert_no_kernel_faults,
     assert_no_probe_errors,
+    assert_rx_capture_valid,
     collect_dmesg,
     compile_dts_to_dtb,
     deploy_and_boot,
@@ -220,7 +221,7 @@ def test_adrv9009_zcu102_hw(board, built_kernel_image_zynqmp, tmp_path):
         "ADRV9009 phy probe signature was not found in kernel dmesg output"
     )
 
-    ctx, _ = open_iio_context(shell)
+    ctx, ip_address = open_iio_context(shell)
 
     found = [d.name for d in ctx.devices]
     expected = {
@@ -240,6 +241,11 @@ def test_adrv9009_zcu102_hw(board, built_kernel_image_zynqmp, tmp_path):
     print(f"$ cat .../axi?jesd204?rx/status\n{rx_status}")
     print(f"$ cat .../axi?jesd204?tx/status\n{tx_status}")
 
+    # --- 8b. Data-path smoke test: capture a real RX buffer. ---
+    import adi  # noqa: PLC0415
+    adrv = adi.adrv9009(uri=f"ip:{ip_address}")
+    assert_rx_capture_valid(adrv, n_samples=2**12, context="adrv9009 initial boot")
+
     # --- 9. Load all four canonical Talise filter profiles ---
     # The remote libiio write path drops its TCP socket when the driver
     # holds the CPU for Talise re-init, surfacing as ``BrokenPipeError``.

test/hw/test_adrv9371_zc706_hw.py

@@ -37,6 +37,7 @@
     acquire_xsa,
     assert_no_kernel_faults,
     assert_no_probe_errors,
+    assert_rx_capture_valid,
     collect_dmesg,
     compile_dts_to_dtb,
     deploy_and_boot,
@@ -143,7 +144,7 @@ def test_adrv9371_zc706_xsa_hw(board, built_kernel_image_zynq, tmp_path):
         "AD9371 driver probe signature not found in dmesg"
     )
 
-    ctx, _ = open_iio_context(shell)
+    ctx, ip_address = open_iio_context(shell)
     found = {d.name for d in ctx.devices if d.name}
     assert any("9371" in n or "adrv9" in n.lower() for n in found), (
         f"No AD9371/ADRV9xxx IIO device found. Devices: {sorted(found)}"
@@ -152,6 +153,11 @@ def test_adrv9371_zc706_xsa_hw(board, built_kernel_image_zynq, tmp_path):
         f"No AD9528 clock device found. Devices: {sorted(found)}"
     )
 
+    # Data-path smoke test: capture a real AD9371 RX buffer.
+    import adi  # noqa: PLC0415
+    ad9371 = adi.ad9371(uri=f"ip:{ip_address}")
+    assert_rx_capture_valid(ad9371, n_samples=2**12, context="ad9371 xsa")
+
 
 # ---------------------------------------------------------------------------
 # System API test

test/hw/test_fmcdaq3_vcu118_hw.py

@@ -37,7 +37,9 @@
     DEFAULT_OUT_DIR,
     assert_no_kernel_faults,
     assert_no_probe_errors,
+    assert_rx_capture_valid,
     collect_dmesg,
+    open_iio_context,
 )
 
 
@@ -65,6 +67,12 @@ def test_fmcdaq3_vcu118_boot_hw(board):
 
     _assert_iio_devices(shell)
 
+    # Data-path smoke test: capture a real AD9680 RX buffer.
+    _, ip_address = open_iio_context(shell)
+    import adi  # noqa: PLC0415
+    daq3 = adi.daq3(uri=f"ip:{ip_address}")
+    assert_rx_capture_valid(daq3, n_samples=2**12, context="fmcdaq3 boot")
+
 
 def _assert_iio_devices(shell) -> None:
     """Fail unless the FMCDAQ3 converters show up under /sys/bus/iio."""