option
MaisonMaison Skill DevOps et CI/CD jetson-customize-camera

jetson-customize-camera

NVIDIA/skills NVIDIA/skills

Activez les capteurs de caméra MIPI/GMSL sur une carte porteuse personnalisée Jetson Thor ou Orin en générant une superposition du noyau DT à partir du fichier DTSI du capteur intégré à l'arborescence.

...Développer tout
0
Heure mise à jour 25 septembre 2026

Personnalisation de la caméra (mise en service des capteurs CSI / MIPI / GMSL)

Présentation

Les puces Tegra264 (Thor) et Tegra234 (Orin) exposent un seul contrôleur tegra-capture-vi géré par NVCSI et un ensemble fixe de ports CSI. La mise en service de la caméra se déroule comme suit :

  1. Sélection du capteur — choisi parmi l’ensemble des références.dtsi fournies par NVIDIA dans l’arborescence pour la plateforme active.
  2. Vérification de la prise en charge du support et du module — effectuée par rapport au Guide de développement des caméras, au Guide d'adaptation §Caméra, au schéma du support, au TRM du module et au plan de brochage du support.
  3. Câblage — dérivé du fichier *.dtsi de la branche principale« tegra-camera- » lorsqu’il existe (le DTSI EST la source de référence en matière de câblage) ; capturé par capteur auprès de l’utilisateur lorsque le capteur est personnalisé.
  4. Superposition du noyau-DT — expansion en C++ du DTSI intégré à l’arborescence, extraction de son corpsfragment@N, ajout à la superposition composite personnalisée .dts pour la cible active (selon ../../references/bsp-customization-kernel-dtb.md), vérifier le composite avec fdtoverlay. /jetson-build-source compile le composite et gère l’ enregistrement OVERLAY_DTB_FILE+= de la configuration du support.

Approche agentique, non pilotée par des tables — la liste des capteurs est construite à l’exécution par recherche globale des fichiers dtbos par capteur dans l’arborescence. Pas de dictionnaire _THOR_CAMERAS, pas de questions.json, pas de moteur de rendu Python dans le chemin d’accès aux questions.

Pas de modification d’ODMDATA — les caméras ne consomment pas de voies UPHY (CSI est un pool PHY distinct). La compétence n’émet qu’une superposition de DT du noyau ; la ligne ODMDATA dans la configuration du support n’est pas modifiée par cette compétence.

La sortie correspond à un seul commit:

  • Le bloc « Camera fragment@N » (plus le nom de l’en-tête Jetson sur la racine du composite s’il n’y figure pas déjà) est ajouté à la superposition personnalisée composite .dts selon ../../references/bsp-customization-kernel-dtb.md → validé dans le dépôt bsp_sources/hardware. /jetson-build-source compile le composite en .dtbo et gère son Makefile ainsi que son enregistrement dans flash-conf.

Quand l'invoquer

  • L’utilisateur indique « activer la caméra », « configurer le CSI », « connecter un capteur Hawk / Owl / IMX », « caméra MIPI », « caméra GMSL », ou demande de lancer tegra-capture-vi / NVCSI sur une carte porteuse personnalisée.
  • Le flash démarre mais v4l2-ctl --list-devices n’affiche aucun canaltegra-capture-vi, OU l’énumération des capteurs sur une nouvelle carte fille doit être confirmée.
  • Un capteur était précédemment activé et l’utilisateur souhaite en ajouter un autre (mise en service multi-capteurs).

Prérequis :

  • Profil actif avec les blocs reference_devkit : + custom_carrier :.
  • /Linux_for_Tegra/.git existe (/jetson-init-source).
  • /jetson-derive-carrier a été exécuté — la branche « flash-conf » du carrier se trouve dans le tracker overlay.
  • Le répertoire /bsp_sources/hardware/nvidia//nv-public/overlay/ existe et contient les fichiers .dtsi par capteur intégrés à l’arborescence (provenant de l’extrait d’archive de la branche A de /jetson-init-source).
  • /bsp_sources/kernel/kernel-noble/include/dt-bindings/ contient les en-têtes de macros dont C++ a besoin (il peut être nécessaire d’ exécutersource_sync.sh si la branche B a été utilisée — voir l’étape 5a.i ci-dessous).
  • Documents de référence enregistrés ou fournis à la demande : Guide de développement de la caméra (dans le miroir bsp_developer_guide ou sur un chemin distinct), Guide d’adaptation §Caméra, schéma du support, TRM du SoC, Guide de conception du module.
  • dtc, cpp, fdtoverlay dans PATH.

Procédure

La procédure détaillée étape par étape (étapes 1 à 7, avec tous les tableaux, blocs de code et portes logiques) se trouve dansle fichier references/procedure.md. Résumé :

  1. Étape 1 — Déterminer la cible active et ouvrir les documents de référence.
  2. Étape 2 — Répertorier les capteurs pris en charge en parcourant les dtbos de caméra par plateforme dans l’arborescence ; les classer en DPHY-direct / GMSL / personnalisés. Ne jamais inventer de capteurs.
  3. Étape 3 / 3a — Vérifier la prise en charge du support et du module par rapport au DTSI, au Guide de développement de la caméra, au Guide d’adaptation §Caméra, au TRM du SoC, au Guide de conception du module, au schéma et à la carte des broches du support. Générer le tableau de câblage EN PREMIER, puis déclencher la porte « confirmer ou personnaliser ».
  4. Étape 4 (parcours personnalisé uniquement) — Questions de câblage par capteur regroupées et remplies automatiquement à partir de la carte des broches du support.
  5. Étape 5 — Ajoutez exactement UN fragment /* custom-bsp: camera: */ au fichier .dts de superposition personnalisée composite (voir ../../references/bsp-customization-kernel-dtb.md). Le chemin « clone » effectue l’expansion C++ du DTSI intégré à l’arborescence ; le chemin « custom » intègre les réponses de l’étape 4 et les tables de mode directement sur place. Définissez de manière idempotente jetson-header-name sur la racine composite. Vérifiez avec dtc + fdtoverlay (porte de pré-compilation à fragment unique ; porte de post-compilation garantissant l’unicité de l’arborescence profonde). Validez via la porte de prévisualisation du message de validation du workflow.
  6. Étape 6 — Vérifier les SFIO des broches CAM auxiliaires (cam_i2c_*,_clk des périphériques externes, GPIO reset/PWDN/PWR_EN) via pin_verifier.py; signaler les divergences de routage à /jetson-customize-pinmux.
  7. Étape 7 — Effectuez une écriture atomique du fichier JSON d’état d’exécution (sidecar) à l’adresse /target-platform/.jetson-customize-camera.json et affichez le titre, puis lancez la chaîne des étapes suivantes en aval via des invites séquentielles « AskUserQuestion » conformément au fichier references/procedure.md Étape 7. La chaîne constitue une étape documentée du workflow, et non une question de clarification — le mode automatique ne la dispense PAS. Ne remplacez jamais les invites par une ligne imprimée « Étape suivante : … ».

Pièges

  • Piège des fragments doubles. Contribuez exactement à UN SEULfragment@N marqué par la caméra au composite. Un deuxième fragment portant des informations de statut déclenche une fusion profonde dtc → des sous-arborescences sœurs en double (par ex. deux tca9546@70) → la première correspondance en exécution rejette l’arborescence profonde fournie par dtsi → la caméra ne procède pas à l’énumération de manière silencieuse. Appliquez le contrôle d’accès uniquement sur le marqueur de cette compétence (Étape 5c).
  • La racine du composite compatible est gérée globalement, et non par cette compétence. Ne pas étendre à partir des DTBO par capteur présentes dans l’arborescence compatibles (contrôlées par le SKU du kit de développement). Corriger la racine du composite si nécessaire.
  • jetson-header-name provenant de n’importe quel DTBO par capteur présent dans l’arborescence. Corrigé, indépendant de l’opérateur ; lire une fois, coller dans la racine des métadonnées.
  • N’ajoutez PAS non plus le fichier DTBO par capteur présent dans l’arborescence à OVERLAY_DTB_FILE. L’enregistrement à la fois de votre superposition rendue ET du fichier DTBO Tegraprésent dans l’arborescence -p3971-camera--overlay.dtbo génère une liaison de sous-périphérique fantôme qui bloque l’énumération de la caméra.
  • La superposition « stub » est un piège connu. Valider tegra-capture-vi { status="okay"; num-channels=; } sans corps de type ports / sensor / nvcsi rend la caméra inutilisable (échec de l’initialisation de tous les canaux). Intégrez le corps COMPLET du capteur via cpp + dtc.
  • Les tables de mode du capteur doivent être intégrées, jamais rédigées à la main. mode, sensor_modes, pixel_phase — copiez mot pour mot à partir du DTSI le plus proche dans l’arborescence.
  • camera_common_regulator_get (null) ERR : -EINVAL = chaînes avdd-reg / iovdd-reg / dvdd-reg manquantes — intégrez l’intégralité du corps du capteur ; les rails toujours actifs se rabattent sur un régulateur factice.
  • Les références externes &label doivent exister dans le fichier __symbols__ du DTB de base. Utilisez target-path = « /tegra-capture-vi » lorsque le label est absent ; sinon,fdtoverlay renvoie un code de sortie non nul avec FDT_ERR_NOTFOUND.
  • Échecde compilation dans dt-bindings/gpio/gpio.h : fichier introuvable = l’arborescence source L4T n’est pas préparée. Relancez /jetson-init-source ( le script source_sync.sh de la branche B récupère les en-têtes). Ne simulez jamais l’ expansion de la macro.
  • Pas de modification d’ODMDATA, pas de modification de la configuration flash. La caméra ne consomme pas de voies UPHY. La valeur ODMDATA="..." de la configuration du support reste inchangée. OVERLAY_DTB_FILE+= relève de l’étape 5.0a de /jetson-build-source — cette procédure ne modifie jamais la configuration flash du porteur.
  • Ne modifiez pas le BSP en amont disponible à l'adresse . Toutes les modifications sont enregistrées dans /Linux_for_Tegra/ (suivi des overlays) et /bsp_sources/ ( fichiers .dts des overlays) selon le modèle de commit « version d'origine + personnalisation ».

Références

  • references/procedure.md — procédure complète étape par étape des étapes 1 à 7 (extraite de ce fichier SKILL.md).
  • references/csi-dt-bindings.md — notes de référence sur les liaisons DT CSI / nvcsi / vi.
  • references/overlay-template.md — conseils sur la structure de superposition « metadata-root + clone-body ».
  • references/camera-overlay-templates/ — modèles .dts.tmpl de départ : dphy-direct.dts.tmpl, gmsl-serdes.dts.tmpl.
  • ../../scripts/pin_verifier.py — Vérificateur de broches HSIO partagé (étape 6).
  • ../../references/platform_template.yaml — documents : bloc utilisé à l'étape 1.
  • ../../context/bsp-customization-workflow.md — protocole d’édition des superpositions.
  • ../jetson-customize-pinmux/SKILL.md — compétence sœur automatiquement invoquée par l’étape 6 pour corriger les incohérences entre les broches HSIO et SFIO (CAM I²C, MCLK, GPIO de réinitialisation).
  • ../jetson-derive-carrier/SKILL.md — doit s’exécuter en premier ; génère la superposition de base du support (le fichier*-dynamic.dtbo) sur laquelle cette compétence empile ensuite ses composantes.
  • ../jetson-init-source/SKILL.md — génère le tracker de superposition + le dépôt bsp_sources (contenant l’ arborescence DTSI par capteurdans hardware/nvidia/) que cette compétence lit et dans lequel elle effectue des commits.
Voir sur GitHub
---
name: jetson-customize-camera
description: Enable MIPI/GMSL camera sensors on a Jetson Thor or Orin custom carrier by rendering a kernel-DT overlay from the in-tree sensor DTSI.
license: Apache-2.0
---

# Customize camera (CSI / MIPI / GMSL sensor bring-up)

## Overview

Tegra264 (Thor) and Tegra234 (Orin) expose a single `tegra-capture-vi`
controller fronted by NVCSI and a fixed set of CSI ports. Camera
bring-up is:

1. **Sensor selection** — picked from the set NVIDIA ships in-tree
   `.dtsi` references for on the active platform.
2. **Carrier + module support check** — verified against the Camera
   Development Guide, Adaptation Guide §Camera, carrier schematic,
   Module TRM, and carrier pinmap.
3. **Wiring** — derived from the in-tree
   `tegra<soc>-camera-<sensor>*.dtsi` when one exists (**the DTSI IS
   the wiring source of truth**); captured per-sensor from the user
   when the sensor is custom.
4. **Kernel-DT overlay** — cpp-expand the in-tree DTSI, extract its
   `fragment@N` body, append into the composite custom overlay
   `.dts` for the active target (per
   [`../../references/bsp-customization-kernel-dtb.md`](../../references/bsp-customization-kernel-dtb.md)),
   verify the composite with `fdtoverlay`.
   `/jetson-build-source` compiles the composite and owns the
   carrier conf's `OVERLAY_DTB_FILE+=` registration.

**Agentic, not table-driven** — sensor list is built at runtime by
globbing in-tree per-sensor dtbos. No `_THOR_CAMERAS` dict, no
`questions.json`, no Python renderer in the question path.

**No ODMDATA edit** — cameras don't consume UPHY lanes (CSI is a
separate PHY pool). The skill emits only a kernel-DT overlay; the
ODMDATA line in the carrier conf is untouched by this skill.

The output is **one commit**:
- Camera `fragment@N` block (plus `jetson-header-name` on the
  composite root if not already present) appended to the composite
  custom overlay `.dts` per
  [`../../references/bsp-customization-kernel-dtb.md`](../../references/bsp-customization-kernel-dtb.md)
  → committed to the `bsp_sources/` hardware repo.
  `/jetson-build-source` compiles the composite to `.dtbo` and
  owns its Makefile + flash-conf registration.

## When to invoke

- The user says "enable camera", "configure CSI", "wire a Hawk /
  Owl / IMX sensor", "MIPI camera", "GMSL camera", or asks to bring
  up `tegra-capture-vi` / NVCSI on a custom carrier.
- Flash boots but `v4l2-ctl --list-devices` shows no
  `tegra-capture-vi` channels, OR sensor enumeration on a fresh
  daughter-card needs to be confirmed.
- A sensor was previously enabled and the user wants to add another
  (multi-sensor bring-up).

**Prerequisites:**

- Active profile with `reference_devkit:` + `custom_carrier:` blocks.
- `<source.root_path>/Linux_for_Tegra/.git` exists
  (`/jetson-init-source`).
- `/jetson-derive-carrier` has run — the carrier flash-conf fork is
  in the overlay tracker.
- `<source.root_path>/bsp_sources/hardware/nvidia/<chip-dir>/nv-public/overlay/`
  exists and contains the in-tree per-sensor `.dtsi` files (sourced
  by `/jetson-init-source`'s Branch A archive extract).
- `<source.root_path>/bsp_sources/kernel/kernel-noble/include/dt-bindings/`
  contains the macro headers cpp needs (`source_sync.sh` may need to
  run if Branch B was used — see Step 5a.i below).
- Source-of-truth docs registered or supplied at prompt:
  Camera Development Guide (in `bsp_developer_guide` mirror or
  separate path), Adaptation Guide §Camera, carrier schematic, SoC
  TRM, Module Design Guide.
- `dtc`, `cpp`, `fdtoverlay` on PATH.

## Procedure

Detailed step-by-step procedure (Steps 1–7, with all tables, code
blocks, and gates) lives in
[`references/procedure.md`](references/procedure.md). Summary:

1. **Step 1** — Resolve active target + open source-of-truth docs.
2. **Step 2** — Enumerate supported sensors by globbing in-tree
   per-platform camera dtbos; classify as DPHY-direct / GMSL /
   custom. Never invent sensors.
3. **Step 3 / 3a** — Cross-check carrier + module support against
   DTSI, Camera Development Guide, Adaptation Guide §Camera, SoC TRM,
   Module Design Guide, schematic, and carrier pinmap. Render the
   wiring table FIRST, then issue the confirm-or-customize gate.
4. **Step 4** (custom path only) — Batched per-sensor wiring
   questions auto-filled from the carrier pinmap.
5. **Step 5** — Append exactly ONE `/* custom-bsp: camera:<sensor> */`
   fragment to the composite custom overlay `.dts` (see
   [`../../references/bsp-customization-kernel-dtb.md`](../../references/bsp-customization-kernel-dtb.md)).
   Clone path cpp-expands the in-tree DTSI; custom path splices Step-4
   answers + mode tables in-place. Idempotently set
   `jetson-header-name` on the composite root. Verify with
   `dtc` + `fdtoverlay` (pre-compile single-fragment gate;
   post-compile deep-tree uniqueness gate). Commit via the
   workflow's commit-message preview gate.
6. **Step 6** — Verify ancillary CAM pin SFIOs (`cam_i2c_*`,
   `extperiph<m>_clk`, reset/PWDN/PWR_EN GPIOs) via
   `pin_verifier.py`; route mismatches to `/jetson-customize-pinmux`.
7. **Step 7** — Atomic-write run-state JSON sidecar at
   `<workspace>/target-platform/<profile-stem>.jetson-customize-camera.json`
   and emit the headline, then drive the downstream next-step chain via
   sequential `AskUserQuestion` prompts per `references/procedure.md`
   Step 7. **The chain is a documented workflow gate, not a clarifying
   question — auto-mode does NOT exempt it.** Never substitute a
   printed "Next step: …" line for the prompts.

## Gotchas

- **Dual-fragment trap.** Contribute exactly ONE camera-tagged
  `fragment@N` to the composite. A second one carrying status
  overrides triggers dtc deep-merge → duplicate sibling subtrees
  (e.g. two `tca9546@70`) → runtime first-match drops the dtsi-
  supplied deep tree → camera silently doesn't enumerate. Gate on
  this skill's marker only (Step 5c).
- **Composite root `compatible` is owned globally, not by this
  skill.** Don't widen from any in-tree per-sensor dtbo's
  `compatible` (devkit-SKU-gated). Fix the composite root if needed.
- **`jetson-header-name` from any in-tree per-sensor dtbo.** Fixed,
  carrier-agnostic; read once, paste onto the metadata root.
- **DO NOT also append the in-tree per-sensor dtbo to
  `OVERLAY_DTB_FILE`.** Registering both your rendered overlay AND
  the in-tree `tegra<soc>-p3971-camera-<sensor>-overlay.dtbo`
  produces a phantom subdev bind that bricks camera enumeration.
- **Stub overlay is a known footgun.** Committing
  `tegra-capture-vi { status="okay"; num-channels=<N>; }` with no
  ports / sensor / nvcsi body bricks the camera (`all channel init
  failed`). Splice the FULL sensor body via cpp + dtc.
- **Sensor mode tables must be spliced, never hand-authored.**
  `mode<N>`, `sensor_modes`, `pixel_phase` — copy verbatim from the
  closest in-tree DTSI.
- **`camera_common_regulator_get (null) ERR: -EINVAL`** = missing
  `avdd-reg` / `iovdd-reg` / `dvdd-reg` strings — splice the FULL
  sensor body; always-on rails fall back to dummy regulator.
- **External `&label` refs must exist in base DTB's `__symbols__`.**
  Use `target-path = "/tegra-capture-vi"` when the label is absent;
  `fdtoverlay` exits non-zero with `FDT_ERR_NOTFOUND` otherwise.
- **`cpp` failure on `dt-bindings/gpio/gpio.h: No such file`** =
  L4T source tree isn't staged. Re-run `/jetson-init-source` (Branch
  B's `source_sync.sh` fetches the headers). Never fabricate the
  macro expansion.
- **No ODMDATA edit, no flash-conf edit.** Camera doesn't consume
  UPHY lanes. The carrier conf's `ODMDATA="..."` is untouched.
  `OVERLAY_DTB_FILE+=` is owned by `/jetson-build-source` Step
  5.0a — this skill never touches the carrier flash conf.
- **Don't touch the upstream BSP at `<bsp_image.root_path>`.** All
  edits land in `<source.root_path>/Linux_for_Tegra/` (overlay
  tracker) and `<source.root_path>/bsp_sources/` (overlay `.dts`)
  under the pristine + customization commit pattern.

## References

- [`references/procedure.md`](references/procedure.md) — full
  step-by-step Steps 1–7 procedure (extracted from this SKILL.md).
- [`references/csi-dt-bindings.md`](references/csi-dt-bindings.md) —
  CSI / nvcsi / vi DT binding reference notes.
- [`references/overlay-template.md`](references/overlay-template.md) —
  guidance on the metadata-root + clone-body overlay shape.
- [`references/camera-overlay-templates/`](references/camera-overlay-templates/)
  — starter `.dts.tmpl` templates: `dphy-direct.dts.tmpl`,
  `gmsl-serdes.dts.tmpl`.
- [`../../scripts/pin_verifier.py`](../../scripts/pin_verifier.py)
  — shared HSIO pin verifier (Step 6).
- [`../../references/platform_template.yaml`](../../references/platform_template.yaml)
  — `documents:` block consumed by Step 1.
- [`../../context/bsp-customization-workflow.md`](../../context/bsp-customization-workflow.md#workflow-invariants)
  — overlay edit protocol.
- [`../jetson-customize-pinmux/SKILL.md`](../jetson-customize-pinmux/SKILL.md) —
  sibling skill auto-invoked by Step 6 to fix HSIO pin SFIO
  mismatches (CAM I²C, MCLK, reset GPIOs).
- [`../jetson-derive-carrier/SKILL.md`](../jetson-derive-carrier/SKILL.md)
  — must run first; produces the carrier base overlay (the
  `*-dynamic.dtbo`) this skill's composite stacks after.
- [`../jetson-init-source/SKILL.md`](../jetson-init-source/SKILL.md) —
  produces the overlay tracker + `bsp_sources` repo (with the
  `hardware/nvidia/<chip-dir>/` per-sensor DTSI tree) this skill
  reads and commits into.

Installer jetson-customize-camera

Téléchargez et décompressez les fichiers de compétences dans votre répertoire .claude/skills/.

Télécharger le ZIP

Clonez le dépôt et copiez les fichiers de compétence dans votre projet.

git clone https://github.com/NVIDIA/skills/tree/main/skills/jetson-customize-camera # Copy SKILL.md to your .claude/skills/ directory

Copier Copier
Configuration rapide: Copiez le dossier de la compétence dans .claude/skills/ Claude détectera automatiquement la compétence et l'utilisera
Dépôt NVIDIA/skills

Compétences similaires

Verification &amp; Quality Assurance
Heure mise à jour 29 juin 2026
klingai-upgrade-migration
Heure mise à jour 3 juillet 2026
base44-cli
Heure mise à jour 29 juin 2026
Railway CLI Management
Heure mise à jour 2 juillet 2026
OR