Add basic native sim tests

Author: tannewt

.github/workflows/run-tests.yml

@@ -88,5 +88,5 @@ jobs:
         uses: ./.github/actions/deps/ports/zephyr-cp
       - name: Set up external
         uses: ./.github/actions/deps/external
-      - name: Run Zephyr build tests
+      - name: Run Zephyr tests
         run: make -C ports/zephyr-cp test

ports/zephyr-cp/CMakeLists.txt

@@ -5,6 +5,11 @@ project(circuitpython)
 
 target_sources(app PRIVATE zephyr_main.c)
 
+# Add I2C emulator control for native_sim testing
+if(CONFIG_BOARD_NATIVE_SIM)
+    target_sources(app PRIVATE native_sim_i2c_emul_control.c)
+endif()
+
 # From: https://github.com/zephyrproject-rtos/zephyr/blob/main/samples/application_development/external_lib/CMakeLists.txt
 # The external static library that we are linking with does not know
 # how to build for this platform so we export all the flags used in

ports/zephyr-cp/Makefile

@@ -46,5 +46,6 @@ all:
 clean-all:
 	rm -rf build build-*
 
-test:
+test: build-native_native_sim/zephyr-cp/zephyr/zephyr.exe
 	pytest cptools/tests
+	pytest tests/ -v

ports/zephyr-cp/boards/native_sim.conf

@@ -4,3 +4,17 @@ CONFIG_NATIVE_SIM_SLOWDOWN_TO_REAL_TIME=n
 
 # So we can test safe mode
 CONFIG_NATIVE_SIM_REBOOT=y
+
+CONFIG_TRACING=y
+CONFIG_TRACING_PERFETTO=y
+CONFIG_TRACING_SYNC=y
+CONFIG_TRACING_BACKEND_POSIX=y
+CONFIG_TRACING_GPIO=y
+
+# I2C emulation for testing
+CONFIG_I2C_EMUL=y
+
+# EEPROM emulation for testing
+CONFIG_EEPROM=y
+CONFIG_EEPROM_AT24=y
+CONFIG_EEPROM_AT2X_EMUL=y

ports/zephyr-cp/boards/native_sim.overlay

@@ -36,4 +36,16 @@
 	};
 };
 
+/* Add emulated I2C devices for testing */
+&i2c0 {
+	at24_eeprom: eeprom@50 {
+		compatible = "atmel,at24";
+		reg = <0x50>;
+		size = <256>;
+		pagesize = <8>;
+		address-width = <8>;
+		timeout = <5>;
+	};
+};
+
 #include "../app.overlay"

ports/zephyr-cp/docs/perfetto-tracing.md

@@ -0,0 +1,150 @@
+# Perfetto Tracing
+
+The Zephyr port supports Perfetto tracing for performance analysis. This document
+describes how to capture, validate, and view traces.
+
+## Capturing Traces
+
+Traces are written to `circuitpython.perfetto-trace` in the port directory when
+running with tracing enabled (e.g., on native_sim).
+
+## Validating Traces
+
+### Using trace_processor
+
+The Perfetto trace_processor tool can validate and query trace files:
+
+```bash
+~/repos/perfetto/tools/trace_processor circuitpython.perfetto-trace
+```
+
+This will download the trace_processor binary if needed and open an interactive
+SQL shell. If the trace loads successfully, you can query it:
+
+```sql
+SELECT COUNT(*) FROM slice;
+```
+
+### Using the Perfetto UI
+
+Open https://ui.perfetto.dev and drag your trace file onto the page.
+
+## Debugging Invalid Traces
+
+### Common Error: Packets Skipped Due to Invalid Incremental State
+
+If trace_processor reports packets being skipped with messages like:
+
+```
+packet_skipped_seq_needs_incremental_state_invalid
+```
+
+This means packets have `SEQ_NEEDS_INCREMENTAL_STATE` (value 2) set but no
+prior packet set `SEQ_INCREMENTAL_STATE_CLEARED` (value 1) to initialize the
+incremental state.
+
+**Root Cause**: The process descriptor packet (which sets `SEQ_INCREMENTAL_STATE_CLEARED`)
+must be emitted before any other trace packets.
+
+**Diagnosis**: Use protoc to inspect the raw trace:
+
+```bash
+protoc --decode_raw < circuitpython.perfetto-trace | head -100
+```
+
+Look for field 13 (sequence_flags) in the first few packets:
+
+- `13: 1` = SEQ_INCREMENTAL_STATE_CLEARED (good - should be first)
+- `13: 2` = SEQ_NEEDS_INCREMENTAL_STATE (requires prior cleared packet)
+
+A valid trace should have the process descriptor with `13: 1` as one of the
+first packets.
+
+**Fix**: Ensure `perfetto_start()` is called before any trace events are emitted.
+The descriptor emit functions in `perfetto_encoder.c` should check:
+
+```c
+if (!started) {
+    perfetto_start();
+}
+```
+
+### Analyzing Raw Trace Structure
+
+To understand the trace structure:
+
+```bash
+# Count total packets
+protoc --decode_raw < circuitpython.perfetto-trace | grep -c "^1 {"
+
+# Find all sequence_flags values
+protoc --decode_raw < circuitpython.perfetto-trace | grep "13:" | sort | uniq -c
+
+# Look for track descriptors (field 60)
+protoc --decode_raw < circuitpython.perfetto-trace | grep -A20 "60 {"
+
+# Look for process descriptors (field 3 inside track_descriptor)
+protoc --decode_raw < circuitpython.perfetto-trace | grep -B5 "3 {"
+```
+
+### Key Protobuf Field Numbers
+
+TracePacket fields:
+
+| Field | Description |
+|-------|-------------|
+| 8 | timestamp |
+| 10 | trusted_packet_sequence_id |
+| 11 | track_event |
+| 12 | interned_data |
+| 13 | sequence_flags |
+| 60 | track_descriptor |
+
+TrackDescriptor fields (inside field 60):
+
+| Field | Description |
+|-------|-------------|
+| 1 | uuid |
+| 2 | name |
+| 3 | process (ProcessDescriptor) |
+| 4 | thread (ThreadDescriptor) |
+| 5 | parent_uuid |
+
+## Build Verification
+
+After modifying tracing code, verify the build is updated:
+
+```bash
+# Check source vs object file timestamps
+ls -la zephyr/subsys/tracing/perfetto/perfetto_encoder.c
+ls -la zephyr/build/zephyr/subsys/tracing/perfetto/CMakeFiles/subsys__tracing__perfetto.dir/perfetto_encoder.c.obj
+```
+
+The object file timestamp must be newer than the source file timestamp. If not,
+rebuild the project before capturing a new trace.
+
+## Architecture
+
+The tracing implementation consists of:
+
+- `perfetto_encoder.c`: Encodes trace packets using nanopb
+- `perfetto_top.c`: Implements Zephyr tracing hooks (sys_trace_*)
+- `perfetto_encoder.h`: Public API and UUID definitions
+
+Key UUIDs:
+
+| Constant | Value | Description |
+|----------|-------|-------------|
+| PROCESS_UUID | 1 | Root process track |
+| ISR_TRACK_UUID | 2 | Interrupt service routine track |
+| TRACE_TRACK_UUID | 3 | Top-level trace track |
+
+### Initialization Flow
+
+1. `SYS_INIT` calls `perfetto_init()` at POST_KERNEL priority 0
+2. `perfetto_init()` calls `perfetto_encoder_init()`
+3. `perfetto_initialized` is set to true
+4. Thread hooks start firing
+5. First emit function calls `perfetto_start()`
+6. `perfetto_start()` emits process descriptor with `SEQ_INCREMENTAL_STATE_CLEARED`
+7. Subsequent packets use `SEQ_NEEDS_INCREMENTAL_STATE`

ports/zephyr-cp/native_sim_i2c_emul_control.c

@@ -0,0 +1,169 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Command-line control for enabling/disabling emulated I2C devices
+ * on native_sim. This allows testing device hot-plug and error scenarios.
+ */
+
+#include <zephyr/kernel.h>
+#include <zephyr/device.h>
+#include <zephyr/drivers/emul.h>
+#include <zephyr/drivers/i2c_emul.h>
+#include <zephyr/init.h>
+#include <zephyr/logging/log.h>
+
+#include "nsi_cmdline.h"
+#include "posix_native_task.h"
+
+LOG_MODULE_REGISTER(i2c_emul_control, LOG_LEVEL_INF);
+
+#define MAX_DISABLED_DEVICES 16
+
+struct disabled_device {
+    const char *name;
+    const struct emul *emul;
+    struct i2c_emul_api mock_api;
+    bool disabled;
+};
+
+static struct disabled_device disabled_devices[MAX_DISABLED_DEVICES];
+static int num_disabled_devices = 0;
+
+static char *disabled_device_args[MAX_DISABLED_DEVICES];
+static int num_disabled_device_args = 0;
+
+/*
+ * Mock transfer function that returns -EIO (NACK) when device is disabled,
+ * or -ENOSYS to fall back to the real emulator.
+ */
+static int disabled_device_transfer(const struct emul *target,
+    struct i2c_msg *msgs,
+    int num_msgs,
+    int addr) {
+    ARG_UNUSED(msgs);
+    ARG_UNUSED(num_msgs);
+    ARG_UNUSED(addr);
+
+    for (int i = 0; i < num_disabled_devices; i++) {
+        if (disabled_devices[i].emul == target) {
+            if (disabled_devices[i].disabled) {
+                LOG_DBG("Device %s is disabled, returning -EIO",
+                    disabled_devices[i].name);
+                return -EIO;
+            }
+            break;
+        }
+    }
+    /* Fall back to normal emulator behavior */
+    return -ENOSYS;
+}
+
+int i2c_emul_control_disable_device(const char *name) {
+    const struct emul *emul = emul_get_binding(name);
+    if (!emul) {
+        LOG_ERR("Emulator '%s' not found", name);
+        return -ENODEV;
+    }
+
+    if (emul->bus_type != EMUL_BUS_TYPE_I2C) {
+        LOG_ERR("Emulator '%s' is not an I2C device", name);
+        return -EINVAL;
+    }
+
+    /* Find existing entry or create new one */
+    int idx = -1;
+    for (int i = 0; i < num_disabled_devices; i++) {
+        if (disabled_devices[i].emul == emul) {
+            idx = i;
+            break;
+        }
+    }
+
+    if (idx < 0) {
+        if (num_disabled_devices >= MAX_DISABLED_DEVICES) {
+            LOG_ERR("Too many disabled devices");
+            return -ENOMEM;
+        }
+        idx = num_disabled_devices++;
+        disabled_devices[idx].name = name;
+        disabled_devices[idx].emul = emul;
+        disabled_devices[idx].mock_api.transfer = disabled_device_transfer;
+
+        /* Install our mock_api to intercept transfers */
+        emul->bus.i2c->mock_api = &disabled_devices[idx].mock_api;
+    }
+
+    disabled_devices[idx].disabled = true;
+    LOG_INF("Disabled I2C emulator: %s", name);
+    return 0;
+}
+
+int i2c_emul_control_enable_device(const char *name) {
+    for (int i = 0; i < num_disabled_devices; i++) {
+        if (strcmp(disabled_devices[i].name, name) == 0) {
+            disabled_devices[i].disabled = false;
+            LOG_INF("Enabled I2C emulator: %s", name);
+            return 0;
+        }
+    }
+    LOG_ERR("Device '%s' not in disabled list", name);
+    return -ENODEV;
+}
+
+bool i2c_emul_control_is_disabled(const char *name) {
+    for (int i = 0; i < num_disabled_devices; i++) {
+        if (strcmp(disabled_devices[i].name, name) == 0) {
+            return disabled_devices[i].disabled;
+        }
+    }
+    return false;
+}
+
+/* Command-line option handler */
+static void cmd_disable_i2c_device(char *argv, int offset) {
+    /* The value is at argv + offset (after the '=' in --disable-i2c=value) */
+    char *value = argv + offset;
+    if (num_disabled_device_args < MAX_DISABLED_DEVICES) {
+        disabled_device_args[num_disabled_device_args++] = value;
+    } else {
+        printk("i2c_emul_control: Too many --disable-i2c arguments, ignoring: %s\n", value);
+    }
+}
+
+static struct args_struct_t i2c_emul_args[] = {
+    {
+        .option = "disable-i2c",
+        .name = "device",
+        .type = 's',
+        .call_when_found = cmd_disable_i2c_device,
+        .descript = "Disable an emulated I2C device by name (can be repeated). "
+            "Example: --disable-i2c=bmi160"
+    },
+    ARG_TABLE_ENDMARKER
+};
+
+static void register_cmdline_opts(void) {
+    nsi_add_command_line_opts(i2c_emul_args);
+}
+
+/* Register command-line options early in boot */
+NATIVE_TASK(register_cmdline_opts, PRE_BOOT_1, 0);
+
+static int apply_disabled_devices(void) {
+    LOG_DBG("Applying %d disabled device(s)", num_disabled_device_args);
+    for (int i = 0; i < num_disabled_device_args; i++) {
+        int rc = i2c_emul_control_disable_device(disabled_device_args[i]);
+        if (rc != 0) {
+            LOG_WRN("Failed to disable I2C device '%s': %d",
+                disabled_device_args[i], rc);
+        }
+    }
+    return 0;
+}
+
+/*
+ * Apply after emulators are initialized.
+ * I2C emulators are registered at POST_KERNEL level, so we need to run
+ * at APPLICATION level to ensure they exist.
+ */
+SYS_INIT(apply_disabled_devices, APPLICATION, 99);