target/ast1060-evb/mctp/system.json5

// Licensed under the Apache-2.0 license

// AST1060-EVB MCTP Echo Server + Client Configuration
// ARM Cortex-M4 @ 200 MHz
// 768KB SRAM (640KB usable), executes from RAM
//
// Memory Layout (PMSAv7-friendly, power-of-2 aligned regions):
//   0x00000000 - 0x00000500: Vector table + kernel annotations (1280 bytes)
//   0x00000500 - 0x00020000: Kernel code (~126KB)
//   0x00020000 - 0x00080000: App flash (384KB: 3 apps × 128KB)
//   0x00080000 - 0x000B0000: App RAM (192KB: 3 apps × 64KB)
//   0x000B0000 - 0x000C0000: Kernel RAM (64KB)
//
// Total: ~768KB, fits within AST1060's 768KB SRAM.
{
    arch: {
        type: "armv7m",
        vector_table_start_address: 0x00000000,
        vector_table_size_bytes: 1280,  // 0x500 (272 vectors + thread/stack annotations)
    },
    kernel: {
        flash_start_address: 0x00000500,  // After vector table + annotations
        flash_size_bytes: 130816,         // ~127KB (ends at 0x00020000, power-of-2 boundary)
        ram_start_address: 0x000B0000,    // After all app RAM
        ram_size_bytes: 65536,            // 64KB
    },
    apps: [
        // ──── I2C Server ────
        // Owns the AST1060 I2C controllers.
        // The MCTP server uses I2C as its transport.
        {
            name: "i2c_server",
            flash_size_bytes: 131072,     // 128KB for server code
            ram_size_bytes: 65536,        // 64KB RAM (register maps + buffers)
            process: {
                name: "i2c server process",
                objects: [
                    {
                        name: "I2C",
                        type: "channel_handler",  // Server side of client→server channel
                    },
                ],
                threads: [
                    {
                        name: "i2c server thread",
                        stack_size_bytes: 4096,   // 4KB stack
                    },
                ],
            },
        },
        // ──── MCTP Server ────
        // Runs the MCTP stack. Receives MCTP operations via IPC,
        // uses I2C transport for on-the-wire communication.
        {
            name: "mctp_server",
            flash_size_bytes: 131072,     // 128KB for MCTP server code
            ram_size_bytes: 65536,        // 64KB RAM (Router state, buffers)
            process: {
                name: "mctp server process",
                objects: [
                    {
                        name: "MCTP",
                        type: "channel_handler",  // Server side: echo client → MCTP server
                    },
                    {
                        name: "I2C",
                        type: "channel_initiator",  // Client side: MCTP server → I2C server
                        handler_app: "i2c_server",
                        handler_object_name: "I2C",
                    },
                ],
                threads: [
                    {
                        name: "mctp server thread",
                        stack_size_bytes: 8192,   // 8KB stack (Router + fragmentation buffers)
                    },
                ],
            },
        },
        // ──── MCTP Echo Client ────
        // Listens for MCTP type-1 messages and echoes the payload back.
        {
            name: "mctp_echo",
            flash_size_bytes: 131072,     // 128KB for echo app
            ram_size_bytes: 65536,        // 64KB RAM
            process: {
                name: "mctp echo process",
                objects: [
                    {
                        name: "MCTP",
                        type: "channel_initiator",  // Client side: echo → MCTP server
                        handler_app: "mctp_server",
                        handler_object_name: "MCTP",
                    },
                ],
                threads: [
                    {
                        name: "mctp echo thread",
                        stack_size_bytes: 4096,   // 4KB stack
                    },
                ],
            },
        },
    ],
}