@typecad/framework-zephyr 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/chips/resolve.js

@@ -7,9 +7,9 @@
 // (from the MCU package's zephyr field) with board-level overrides (from the
 // board package's zephyr field).
 //
-// When a board package carries Zephyr config, this path replaces the
-// hardcoded chip descriptor registry. When it doesn't (legacy), chipForTarget
-// still works as the fallback.
+// This is the ONE resolution path: every board's chip view reconstructs
+// from its generated manifest — there is no curated registry to fall back
+// to.
 // ---------------------------------------------------------------------------
 /** Collect an indexed array of objects reconstructed from flat dot-path keys. */
 function collectIndexed(bc, prefix, build) {
@@ -34,23 +34,64 @@ function collectIndexed(bc, prefix, build) {
 function collectBusControllers(bc, prefix) {
     return collectIndexed(bc, prefix, (m, i) => {
         const nodeLabel = m.get(`${prefix}.${i}.nodeLabel`);
-        return nodeLabel ? { nodeLabel } : null;
+        if (!nodeLabel)
+            return null;
+        // Optional pinctrl synthesis data (nested object; string arrays arrive
+        // comma-joined from the board-constants flattener).
+        const splitCsv = (v) => typeof v === 'string' && v.length > 0
+            ? v.split(',').map((s) => s.trim()).filter(Boolean)
+            : undefined;
+        const include = m.get(`${prefix}.${i}.pinctrl.include`);
+        const pinmux = splitCsv(m.get(`${prefix}.${i}.pinctrl.pinmux`));
+        const inputPinmux = splitCsv(m.get(`${prefix}.${i}.pinctrl.inputPinmux`));
+        const defines = splitCsv(m.get(`${prefix}.${i}.pinctrl.defines`));
+        const pinctrlRef = m.get(`${prefix}.${i}.pinctrlRef`);
+        const props = splitCsv(m.get(`${prefix}.${i}.props`));
+        return {
+            nodeLabel,
+            ...(include && pinmux
+                ? {
+                    pinctrl: {
+                        include,
+                        pinmux,
+                        ...(inputPinmux ? { inputPinmux } : {}),
+                        ...(defines ? { defines } : {}),
+                    },
+                }
+                : {}),
+            ...(pinctrlRef ? { pinctrlRef } : {}),
+            ...(props ? { props } : {}),
+        };
     });
 }
 /**
  * Try to derive a ZephyrChipDescriptor from board/MCU package constants.
  *
  * Returns null when no zephyr info is available in the board constants
- * (the caller should fall back to the hardcoded chipForTarget registry).
+ * (the caller should treat the board as unresolved — NO_BOARD_CHIP).
  */
 export function resolveChipFromBoard(bc) {
     if (!bc)
         return null;
     const boardTarget = bc.get('build.frameworks.zephyr');
-    if (!boardTarget)
+    // MCU-silicon entry: an MCU-only config (no board package) carries the
+    // chip facts under zephyr.* without any build.frameworks target (the
+    // build target comes from frameworkData instead — a custom board name).
+    const socsRaw = bc.get('zephyr.socs');
+    if (!boardTarget && !socsRaw)
         return null;
+    const socs = typeof socsRaw === 'string' && socsRaw.length > 0
+        ? socsRaw.split(',').map((s) => s.trim()).filter(Boolean)
+        : [];
+    // Chip identity: the board target when a board resolved it, else the SoC
+    // (an MCU-only chip — its "board" is the generated custom board).
+    const id = boardTarget ?? socs[0] ?? 'custom';
     const zGpioController = bc.get('zephyr.gpioController');
-    const soc = bc.get('mcu.id') ?? '';
+    // The soc name: MCU packages key it under mcu.id; generated board
+    // manifests carry it as the second segment of the qualified target.
+    const soc = bc.get('mcu.id')
+        ?? (socs.length > 0 ? socs[0] : undefined)
+        ?? (boardTarget && boardTarget.includes('/') ? boardTarget.split('/')[1] : '');
     // ── Build mutable sub-objects, then construct the final descriptor ──────
     const gc = collectIndexed(bc, 'zephyr.gpioControllers', (m, i) => {
         const nodelabel = m.get(`zephyr.gpioControllers.${i}.nodelabel`);
@@ -81,29 +122,177 @@ export function resolveChipFromBoard(bc) {
     const pwmSpecs = collectIndexed(bc, 'zephyr.pwm.specs', (m, i) => {
         const pin = m.get(`zephyr.pwm.specs.${i}.pin`);
         const dtSpec = m.get(`zephyr.pwm.specs.${i}.dtSpec`);
-        if (pin != null && dtSpec)
-            return { pin, dtSpec };
-        return null;
+        const controller = m.get(`zephyr.pwm.specs.${i}.controller`);
+        const channel = m.get(`zephyr.pwm.specs.${i}.channel`);
+        const periodNs = m.get(`zephyr.pwm.specs.${i}.periodNs`);
+        const polarity = m.get(`zephyr.pwm.specs.${i}.polarity`);
+        const pinctrl = m.get(`zephyr.pwm.specs.${i}.pinctrl`);
+        // Board-shipped alias form (dtSpec) or synthesized form (controller +
+        // channel → overlay-generated alias) — at least one, else drop the entry.
+        if (pin == null || !(dtSpec || (controller && channel != null)))
+            return null;
+        return {
+            pin,
+            ...(dtSpec ? { dtSpec } : {}),
+            ...(controller ? { controller } : {}),
+            ...(channel != null ? { channel } : {}),
+            ...(periodNs != null ? { periodNs } : {}),
+            ...(polarity ? { polarity } : {}),
+            ...(pinctrl ? { pinctrl } : {}),
+        };
     });
     const adcNodeLabel = bc.get('zephyr.adc.nodeLabel');
+    // PWM timer input clock — feeds the overlay's 16-bit prescaler derivation.
+    const pwmClockHz = bc.get('zephyr.pwm.clockHz');
+    // PWM matrix (ESP32 LEDC): any listed pin can carry any channel; channels
+    // are assigned to the driven pins at build time (dt-config/overlay.ts).
+    const matrixController = bc.get('zephyr.pwm.matrix.controller');
+    const matrixChannelCount = bc.get('zephyr.pwm.matrix.channelCount');
+    const matrixPins = collectIndexed(bc, 'zephyr.pwm.matrix.pins', (m, i) => m.get(`zephyr.pwm.matrix.pins.${i}`) ?? null);
+    const pwmMatrix = matrixController && matrixChannelCount
+        ? { controller: matrixController, channelCount: matrixChannelCount, pins: matrixPins }
+        : undefined;
     const adcResolution = bc.get('zephyr.adc.resolution');
     const adcVref = bc.get('zephyr.adc.vrefMv');
+    const adcGain = bc.get('zephyr.adc.gain');
+    const adcReference = bc.get('zephyr.adc.reference');
     const adcChannels = collectIndexed(bc, 'zephyr.adc.channels', (m, i) => {
         const pin = m.get(`zephyr.adc.channels.${i}.pin`);
         const channel = m.get(`zephyr.adc.channels.${i}.channel`);
-        if (pin != null && channel != null)
-            return { pin, channel };
+        const pinctrl = m.get(`zephyr.adc.channels.${i}.pinctrl`);
+        const controller = m.get(`zephyr.adc.channels.${i}.controller`);
+        if (pin != null && channel != null) {
+            return { pin, channel, ...(pinctrl ? { pinctrl } : {}), ...(controller ? { controller } : {}) };
+        }
+        return null;
+    });
+    const dacDevice = bc.get('zephyr.dac.device');
+    const dacChannels = collectIndexed(bc, 'zephyr.dac.channels', (m, i) => {
+        const pin = m.get(`zephyr.dac.channels.${i}.pin`);
+        const channel = m.get(`zephyr.dac.channels.${i}.channel`);
+        const resolution = m.get(`zephyr.dac.channels.${i}.resolution`);
+        if (pin != null && channel != null) {
+            return { pin, channel, resolution: resolution ?? 12 };
+        }
         return null;
     });
     const wdtNodeLabel = bc.get('zephyr.wdt.nodeLabel');
+    // Hardware counters (Zephyr counter devices): nodeLabel always; the child
+    // form carries the timer parent the overlay attaches the (label-less)
+    // counter child to.
+    const hwtimerControllers = collectIndexed(bc, 'zephyr.hwtimer.controllers', (m, i) => {
+        const nodeLabel = m.get(`zephyr.hwtimer.controllers.${i}.nodeLabel`);
+        const counterParent = m.get(`zephyr.hwtimer.controllers.${i}.counterParent`);
+        if (!nodeLabel)
+            return null;
+        return { nodeLabel, ...(counterParent ? { counterParent } : {}) };
+    });
+    // Storage partition synthesis (boards whose DTS ships no storage_partition
+    // — see ZephyrChipDescriptor.storage).
+    const storageOffset = bc.get('zephyr.storage.offset');
+    const storageSize = bc.get('zephyr.storage.size');
+    const storagePreexisting = bc.get('zephyr.storage.preexisting');
+    // USB device (CDC-ACM): zephyr.usb.controller + zephyr.usb.cdcInstances
+    // (+ optional vid/pid for the device descriptor).
+    const usbController = bc.get('zephyr.usb.controller');
+    const usbCdcInstances = bc.get('zephyr.usb.cdcInstances');
+    const usbVid = bc.get('zephyr.usb.vid');
+    const usbPid = bc.get('zephyr.usb.pid');
+    // Optional 1200-baud touch-to-reset data (BOSSA-bootloader boards).
+    const trFlag = bc.get('zephyr.usb.touchReset.flagAddress');
+    const trMagic = bc.get('zephyr.usb.touchReset.magic');
+    const trVid = bc.get('zephyr.usb.touchReset.bootloaderVid');
+    const trPid = bc.get('zephyr.usb.touchReset.bootloaderPid');
+    const probeMethods = collectIndexed(bc, 'zephyr.probeMethods', (m, i) => {
+        const id = m.get(`zephyr.probeMethods.${i}.id`);
+        const runner = m.get(`zephyr.probeMethods.${i}.runner`);
+        if (!id || !runner)
+            return null;
+        const argsRaw = m.get(`zephyr.probeMethods.${i}.args`);
+        const description = m.get(`zephyr.probeMethods.${i}.description`);
+        const debugRaw = m.get(`zephyr.probeMethods.${i}.debug`);
+        const debugInterface = m.get(`zephyr.probeMethods.${i}.debugInterface`);
+        const debugDevice = m.get(`zephyr.probeMethods.${i}.debugDevice`);
+        const debugCfgRaw = m.get(`zephyr.probeMethods.${i}.debugCfg`);
+        const debugCfgSourceRaw = m.get(`zephyr.probeMethods.${i}.debugCfgSource`);
+        // Args are comma-joined (west flags never carry commas); cfg lines are
+        // newline-joined (tcl legally contains commas).
+        const split = (v) => typeof v === 'string' && v.length > 0 ? v.split(',') : undefined;
+        const splitLines = (v) => typeof v === 'string' && v.length > 0 ? v.split('\n') : undefined;
+        const args = split(argsRaw);
+        return {
+            id,
+            runner,
+            ...(args ? { args } : {}),
+            ...(description ? { description } : {}),
+            ...(debugRaw !== undefined ? { debug: debugRaw } : {}),
+            ...(debugInterface ? { debugInterface: debugInterface } : {}),
+            ...(debugDevice ? { debugDevice } : {}),
+            ...(split(debugCfgRaw) ? { debugCfg: splitLines(debugCfgRaw) } : {}),
+            ...(split(debugCfgSourceRaw) ? { debugCfgSource: splitLines(debugCfgSourceRaw) } : {}),
+        };
+    });
     const wifiSupported = bc.get('zephyr.wifi.supported');
+    // ── Custom-board generator inputs (MCU silicon) ─────────────────────────
+    // Only complete when the MCU package carried a default console + clock
+    // plan — without those there is nothing to generate a board from.
+    const consoleNodeLabel = bc.get('zephyr.console.nodeLabel');
+    const consoleTx = bc.get('zephyr.console.tx');
+    const consoleRx = bc.get('zephyr.console.rx');
+    const consoleSpeed = bc.get('zephyr.console.speed');
+    const hseMHz = bc.get('zephyr.clocks.hseMHz');
+    const pllDivM = bc.get('zephyr.clocks.pll.divM');
+    const pllMulN = bc.get('zephyr.clocks.pll.mulN');
+    const pllDivP = bc.get('zephyr.clocks.pll.divP');
+    const pllDivQ = bc.get('zephyr.clocks.pll.divQ');
+    const sysMHz = bc.get('zephyr.clocks.sysMHz');
+    const dtsIncludesRaw = bc.get('zephyr.dtsIncludes');
+    const usbNode = bc.get('zephyr.usb.usbNode');
+    const usbPinctrlRaw = bc.get('zephyr.usb.pinctrl');
+    const usbPinctrl = typeof usbPinctrlRaw === 'string' && usbPinctrlRaw.length > 0
+        ? usbPinctrlRaw.split(',').map((s) => s.trim()).filter(Boolean)
+        : undefined;
+    const cbAdcNodeLabel = bc.get('zephyr.adcNode.nodeLabel');
+    const cbAdcClockSource = bc.get('zephyr.adcNode.clockSource');
+    const cbAdcPrescaler = bc.get('zephyr.adcNode.prescaler');
+    const cbAdcPinctrl = bc.get('zephyr.adcNode.pinctrl');
+    const customBoard = socs.length > 0 &&
+        consoleNodeLabel && consoleTx && consoleRx &&
+        hseMHz != null && pllDivM != null && pllMulN != null && pllDivP != null &&
+        pllDivQ != null && sysMHz != null
+        ? {
+            socs,
+            dtsIncludes: typeof dtsIncludesRaw === 'string' && dtsIncludesRaw.length > 0
+                ? dtsIncludesRaw.split(',').map((s) => s.trim()).filter(Boolean)
+                : [],
+            console: {
+                nodeLabel: consoleNodeLabel,
+                tx: consoleTx,
+                rx: consoleRx,
+                speed: consoleSpeed ?? 115200,
+            },
+            clocks: {
+                hseMHz,
+                pll: { divM: pllDivM, mulN: pllMulN, divP: pllDivP, divQ: pllDivQ },
+                sysMHz,
+                ahbPrescaler: bc.get('zephyr.clocks.ahbPrescaler') ?? 1,
+                apb1Prescaler: bc.get('zephyr.clocks.apb1Prescaler') ?? 1,
+                apb2Prescaler: bc.get('zephyr.clocks.apb2Prescaler') ?? 1,
+            },
+            ...(usbNode ? { usbNode } : {}),
+            ...(usbPinctrl ? { usbPinctrl } : {}),
+            ...(cbAdcNodeLabel && cbAdcClockSource && cbAdcPrescaler != null && cbAdcPinctrl
+                ? { adcNode: { nodeLabel: cbAdcNodeLabel, clockSource: cbAdcClockSource, prescaler: cbAdcPrescaler, pinctrl: cbAdcPinctrl } }
+                : {}),
+        }
+        : undefined;
     // ── Construct the final readonly descriptor ─────────────────────────────
     const gpio = {
         dtSpecs,
         ...(intPins.length > 0 ? { interruptPins: intPins } : {}),
     };
     return {
-        id: boardTarget,
+        id,
         soc,
         gpioController: zGpioController ?? 'gpio0',
         ...(gc.length > 0 ? { gpioControllers: gc } : {}),
@@ -111,11 +300,105 @@ export function resolveChipFromBoard(bc) {
         ...(i2cControllers.length > 0 ? { i2c: { controllers: i2cControllers } } : {}),
         ...(spiControllers.length > 0 ? { spi: { controllers: spiControllers } } : {}),
         ...(uartControllers.length > 0 ? { uart: { controllers: uartControllers } } : {}),
-        ...(pwmSpecs.length > 0 ? { pwm: { specs: pwmSpecs } } : {}),
+        ...(pwmSpecs.length > 0 || pwmMatrix
+            ? {
+                pwm: {
+                    specs: pwmSpecs,
+                    ...(pwmMatrix ? { matrix: pwmMatrix } : {}),
+                    ...(pwmClockHz ? { clockHz: pwmClockHz } : {}),
+                },
+            }
+            : {}),
         ...(adcNodeLabel || adcResolution != null || adcVref != null || adcChannels.length > 0
-            ? { adc: { nodeLabel: adcNodeLabel ?? 'adc', resolution: adcResolution ?? 12, vrefMv: adcVref ?? 3000, channels: adcChannels } }
+            ? {
+                adc: {
+                    nodeLabel: adcNodeLabel ?? 'adc',
+                    resolution: adcResolution ?? 12,
+                    vrefMv: adcVref ?? 3000,
+                    channels: adcChannels,
+                    ...(adcGain ? { gain: adcGain } : {}),
+                    ...(adcReference ? { reference: adcReference } : {}),
+                },
+            }
             : {}),
+        ...(dacDevice && dacChannels.length > 0 ? { dac: { device: dacDevice, channels: dacChannels } } : {}),
         ...(wdtNodeLabel ? { wdt: { nodeLabel: wdtNodeLabel } } : {}),
+        ...(hwtimerControllers.length > 0 ? { hwtimer: { controllers: hwtimerControllers } } : {}),
+        ...(storageOffset != null && storageSize != null
+            ? { storage: { offset: storageOffset, size: storageSize, ...(storagePreexisting ? { preexisting: true } : {}) } }
+            : {}),
+        ...(usbController && usbCdcInstances && usbCdcInstances > 0
+            ? {
+                usb: {
+                    controller: usbController,
+                    cdcInstances: usbCdcInstances,
+                    ...(usbVid ? { vid: usbVid } : {}),
+                    ...(usbPid ? { pid: usbPid } : {}),
+                    ...(trFlag != null && trMagic != null
+                        ? {
+                            touchReset: {
+                                flagAddress: trFlag,
+                                magic: trMagic,
+                                ...(trVid ? { bootloaderVid: trVid } : {}),
+                                ...(trPid ? { bootloaderPid: trPid } : {}),
+                            },
+                        }
+                        : {}),
+                },
+            }
+            : {}),
         ...(wifiSupported ? { wifi: { supported: true } } : {}),
+        ...(probeMethods.length > 0 ? { probeMethods } : {}),
+        ...(customBoard ? { customBoard } : {}),
+    };
+}
+/**
+ * Board-level PWM specs from the generated board manifest (zephyr.pwm.specs.*
+ * — the pwm-leds facts boardgen emits on virtual pins 8192+). The active
+ * chip's spec table is silicon-curated; these JOIN it (see mergeBoardPwmSpecs)
+ * so a board's own devicetree-aliased PWM LED is addressable without curation.
+ */
+export function boardPwmSpecsFromConstants(bc) {
+    if (!bc)
+        return [];
+    const specs = [];
+    for (let i = 0; i < 256; i++) {
+        const pin = bc.get(`zephyr.pwm.specs.${i}.pin`);
+        if (pin == null)
+            break;
+        const dtSpec = bc.get(`zephyr.pwm.specs.${i}.dtSpec`);
+        const controller = bc.get(`zephyr.pwm.specs.${i}.controller`);
+        const channel = bc.get(`zephyr.pwm.specs.${i}.channel`);
+        if (!(dtSpec || (controller && channel != null)))
+            continue;
+        specs.push({
+            pin,
+            ...(dtSpec ? { dtSpec } : {}),
+            ...(controller ? { controller } : {}),
+            ...(channel != null ? { channel } : {}),
+        });
+    }
+    return specs;
+}
+/**
+ * Merge board-level PWM specs into a chip descriptor. Collision rule: a
+ * board spec whose pin OR dtSpec already exists in the chip's table is
+ * dropped (the curated entry wins — e.g. the XIAO's hand-tuned pwm-led0
+ * spec). Returns the chip unchanged when nothing joins.
+ */
+export function mergeBoardPwmSpecs(chip, boardSpecs) {
+    if (boardSpecs.length === 0)
+        return chip;
+    const existing = chip.pwm?.specs ?? [];
+    const joining = boardSpecs.filter((s) => !existing.some((e) => e.pin === s.pin || (s.dtSpec != null && e.dtSpec === s.dtSpec)));
+    if (joining.length === 0)
+        return chip;
+    return {
+        ...chip,
+        pwm: {
+            specs: [...existing, ...joining],
+            ...(chip.pwm?.matrix ? { matrix: chip.pwm.matrix } : {}),
+            ...(chip.pwm?.clockHz ? { clockHz: chip.pwm.clockHz } : {}),
+        },
     };
 }

package/dist/chips/soc/.d.ts

@@ -0,0 +1,2 @@
+import type { ZephyrChipDescriptor } from '../types.js';
+export declare const _SOC: ZephyrChipDescriptor;

package/dist/chips/soc/.js

@@ -0,0 +1,129 @@
+// GENERATED by scripts/gen-soc-descriptors.mjs — consolidated from the
+// board-xiao-nrf52840 + mcu-nrf52840 package data (the exact flatten+reconstruct the build
+// performed). Curated additions: tier/pinNaming/excludedPins. Regenerate
+// only alongside a descriptor-type change; hand-edit the curated table in
+// the script, not this file.
+export const _SOC = {
+    "id": "xiao_ble/nrf52840",
+    "soc": "",
+    "gpioController": "gpio0",
+    "gpioControllers": [
+        {
+            "nodelabel": "gpio0",
+            "minPin": 0,
+            "maxPin": 31
+        },
+        {
+            "nodelabel": "gpio1",
+            "minPin": 32,
+            "maxPin": 47
+        }
+    ],
+    "gpio": {
+        "dtSpecs": [
+            {
+                "pin": 26,
+                "dtSpec": "led0"
+            },
+            {
+                "pin": 30,
+                "dtSpec": "led1"
+            },
+            {
+                "pin": 6,
+                "dtSpec": "led2"
+            }
+        ]
+    },
+    "i2c": {
+        "controllers": [
+            {
+                "nodeLabel": "i2c1"
+            }
+        ]
+    },
+    "spi": {
+        "controllers": [
+            {
+                "nodeLabel": "spi2"
+            }
+        ]
+    },
+    "uart": {
+        "controllers": [
+            {
+                "nodeLabel": "uart0"
+            }
+        ]
+    },
+    "pwm": {
+        "specs": [
+            {
+                "pin": 17,
+                "dtSpec": "pwm-led0"
+            }
+        ],
+        "maxFrequencyHz": 2000000,
+        "resolutionBits": 16
+    },
+    "adc": {
+        "nodeLabel": "adc",
+        "resolution": 12,
+        "vrefMv": 3000,
+        "channels": [
+            {
+                "pin": 2,
+                "channel": 0
+            },
+            {
+                "pin": 3,
+                "channel": 1
+            },
+            {
+                "pin": 28,
+                "channel": 2
+            },
+            {
+                "pin": 29,
+                "channel": 3
+            }
+        ]
+    },
+    "wdt": {
+        "nodeLabel": "wdt0"
+    },
+    "usb": {
+        "controller": "zephyr_udc0",
+        "cdcInstances": 1,
+        "vid": "0x2FE3",
+        "pid": "0x0003"
+    },
+    "probeMethods": [
+        {
+            "id": "jlink",
+            "runner": "jlink",
+            "description": "J-Link probe (SWD)",
+            "debug": true,
+            "debugInterface": "swd",
+            "debugDevice": "nRF52840_xxAA"
+        },
+        {
+            "id": "openocd",
+            "runner": "openocd",
+            "description": "Any SWD probe openocd supports (CMSIS-DAP, cheap clones)",
+            "debug": true,
+            "debugInterface": "swd",
+            "debugCfgSource": [
+                "interface/stlink.cfg",
+                "target/nrf52.cfg"
+            ]
+        },
+        {
+            "id": "uf2",
+            "runner": "uf2",
+            "description": "Bootloader UF2 drag-and-drop: double-tap reset",
+            "debug": false
+        }
+    ],
+    "tier": "validated"
+};

package/dist/chips/soc/esp32.d.ts

@@ -0,0 +1,2 @@
+import type { ZephyrChipDescriptor } from '../types.js';
+export declare const ESP32_SOC: ZephyrChipDescriptor;

package/dist/chips/soc/esp32.js

@@ -0,0 +1,120 @@
+// Hand-maintained descriptor table — mechanically migrated from the
+// board-esp32-devkit + mcu-esp32 package data (the exact flatten+reconstruct the build
+// performed). Curated additions: tier/pinNaming/excludedPins. Regenerate
+// only alongside a descriptor-type change (edit this file; the original
+// migration script was never committed).
+export const ESP32_SOC = {
+    "id": "esp32_devkitc/esp32/procpu",
+    "soc": "esp32",
+    "gpioController": "gpio0",
+    "gpioControllers": [
+        {
+            "nodelabel": "gpio0",
+            "minPin": 0,
+            "maxPin": 31
+        },
+        {
+            "nodelabel": "gpio1",
+            "minPin": 32,
+            "maxPin": 39
+        }
+    ],
+    "gpio": {
+        "dtSpecs": [
+            {
+                "pin": 0,
+                "dtSpec": "sw0"
+            }
+        ],
+        "interruptPins": [
+            {
+                "pin": 0,
+                "dtSpec": "sw0"
+            }
+        ]
+    },
+    "i2c": {
+        "controllers": [
+            {
+                "nodeLabel": "i2c0"
+            }
+        ]
+    },
+    "spi": {
+        "controllers": [
+            {
+                "nodeLabel": "spi2"
+            },
+            {
+                "nodeLabel": "spi3"
+            }
+        ]
+    },
+    "uart": {
+        "controllers": [
+            {
+                "nodeLabel": "uart1"
+            },
+            {
+                "nodeLabel": "uart2"
+            }
+        ]
+    },
+    "adc": {
+        "nodeLabel": "adc0",
+        "resolution": 12,
+        "vrefMv": 1100,
+        "channels": [
+            {
+                "pin": 36,
+                "channel": 0
+            },
+            {
+                "pin": 37,
+                "channel": 1
+            },
+            {
+                "pin": 38,
+                "channel": 2
+            },
+            {
+                "pin": 39,
+                "channel": 3
+            },
+            {
+                "pin": 32,
+                "channel": 4
+            },
+            {
+                "pin": 33,
+                "channel": 5
+            },
+            {
+                "pin": 34,
+                "channel": 6
+            },
+            {
+                "pin": 35,
+                "channel": 7
+            }
+        ]
+    },
+    "wdt": {
+        "nodeLabel": "wdt0"
+    },
+    "wifi": {
+        "supported": true
+    },
+    "tier": "validated",
+    "pinNaming": "esp32-gpio",
+    "excludedPins": [
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+        16,
+        17
+    ]
+};

package/dist/chips/soc/esp32c3.d.ts

@@ -0,0 +1,2 @@
+import type { ZephyrChipDescriptor } from '../types.js';
+export declare const ESP32C3_SOC: ZephyrChipDescriptor;