Hsb Ip Def

NVIDIAOfficialCreated by Holoscan TeamDistributed by NVIDIA

Skill
Tool integration
Software development
Apache-2.0
Medium risk
Has scripts

From the author

Generate, validate, compare, or explain HSB HOLOLINK_def.svh macros. Do not use for FPGA_top.sv wrappers or packetizer-only derivation. Generation runs bundled Python scripts locally through shell commands and writes validated .svh output files after user-confirmed paths.

— the description by Holoscan Team

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The hsb-ip-def skill provides a structured approach to managing SystemVerilog configuration macros for the Holoscan Sensor Bridge (HSB) IP. It enables users to generate, validate, explain, and compare HOLOLINK_def.svh files, ensuring that macro definitions align with board-level requirements and IP constraints. The skill leverages bundled Python scripts to perform these operations, providing a reliable interface for configuring HSB IP revisions 16'h2603 and 16'h2604.

What it does

Generates HOLOLINK_def.svh files based on user-confirmed board requirements.
Validates existing configuration files using a dedicated linting script.
Explains macro semantics, legal values, and their impact on top-level ports.
Compares two configuration files to identify semantic differences.
Provides warnings for potential configuration footguns, such as HD-W3xx issues.
Integrates with other HSB skills for top-level wrapper creation and packetizer derivation.

When to use it

When you need to create a new HOLOLINK_def.svh file for a custom HSB board design.
When you need to verify that an existing configuration file is valid and follows IP constraints.
When you need to understand the effect of specific macros on the HSB IP dataplane or clocking.
When you need to diff two configurations to understand changes between board revisions.

Advantages

Ensures configuration consistency through automated validation.
Prevents common configuration errors with built-in rule checking.
Provides clear, grounded explanations for complex macro interactions.
Maintains compatibility with specific HSB IP revisions.

Usage examples

“Generate a new HOLOLINK_def.svh for a high-bandwidth single-sensor board.”: The agent will initiate the generation workflow, asking for board requirements one by one, building a profile, and running the generation script upon confirmation.
“Validate my current HOLOLINK_def.svh and check for any warnings.”: The agent will run the validation script, report any errors or warnings, and specifically highlight any HD-W3xx footgun warnings.
“Is it legal to set HOST_WIDTH=512 and PTP_CLK_FREQ=90_000_000?”: The agent will use the validation script or macro references to determine if the combination is legal and explain the reasoning.
“Compare my local def file with the baseline configuration.”: The agent will run the comparison script and provide a summary of the semantic differences between the two files.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/nvidia/hsb-ip-def/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip hsb-ip-def.zip -d .agents/skills

Documentation by Holoscan Team

HSB IP Def Skill

Purpose

Use this skill through four workflows:

Generate a HOLOLINK_def.svh from confirmed board requirements.
Validate an existing def file with the bundled validator.
Explain / Reason about HSB IP macros, legality, and macro-driven ports.
Compare two def files semantically.

Scope

This skill owns the contents of HOLOLINK_def.svh: \definedirectives,localparamarrays, theHOLOLINK_pkgwrapper, and boot-timeinit_reg[]sequence. The surrounding top-level wrapper is owned byhsb-ip-create-top; packetizer-only profile derivation can be delegated to hsb-ip-packetizer`.

The file must use the standard guard plus package HOLOLINK_pkg wrapper. Load references/macro-reference.md for the full wrapper requirement and per-macro semantics.

Prerequisites

Python 3.9+ is required for the bundled scripts; PyYAML is required when reading YAML profiles.
The user must confirm file writes and shell commands unless they already asked for that exact operation.
A concrete def file path, pasted content, or confirmed generation profile is required before script-backed validation or generation.
Live HSB IP source is optional but preferred when validating against a specific checked-out IP revision.

Instructions

Run bundled script preflight from references/script-usage.md before Generate, Validate, Compare, or script-backed legality checks.
Never silently default a macro during Generate. Show the proposed value or inferred requirement and get user confirmation.
Ask one requirements question per turn during chat-driven Generate.
Use sensor-agnostic language unless the user says the design is camera-specific.
Avoid unsupported "typical", "common", "most designs", or corpus-frequency claims. Anchor choices to IP behavior, documented constraints, or user requirements.
Always surface HD-W3xx footgun warnings, even when the user asks only about errors.
Do not generate FPGA_top.sv; offer handoff to hsb-ip-create-top after a generated def file is validated.
Treat unfamiliar macros as project-specific unless they are documented in this skill's references or live HSB IP source.

Security Considerations

This skill can read and write local files and run shell commands through its bundled scripts. Before running a command or writing a file, state the command or path and get user confirmation unless the user already explicitly requested that exact operation. For pasted HOLOLINK_def.svh content, write only to a safely generated file in an isolated temporary directory and remove it after validation unless the user asks to keep it.

Version, Compatibility, And Live Source

This skill targets HSB IP rev 16'h2604 and is backward-compatible with 16'h2603. Live HSB IP source supersedes bundled references.

When source-sensitive behavior matters:

Locate <hsb-ip-root>/top/HOLOLINK_top.sv. Known roots include hw/nvcpu_dgx_fpga/vrtl/hololink/ and public-release fpga/nv_hsb_ip/.
Read HOLOLINK_REV and HOLOLINK_BACKWARD_COMPAT_REV.
Trust live source for consumed macros, port gates, and RTL behavior when it differs from bundled references.
Pass --ip-source <root> to scripts/validate_def.py when validating against a known source root.

Public-doc baseline:

https://github.com/nvidia-holoscan/holoscan-sensor-bridge/blob/release-2.6.0-EA/docs/user_guide/ip_integration.md
https://github.com/nvidia-holoscan/holoscan-sensor-bridge/blob/release-2.6.0-EA/docs/user_guide/port_description.md

Workflow Decision

Generate when the user asks to create, scaffold, draft, design, or produce a HOLOLINK_def.svh.
Validate when the user asks to lint, check, validate, or review a HOLOLINK_def.svh.
Explain / Reason when the user asks what a macro does, whether a combination is legal, why validation fails, or how a macro affects HOLOLINK_top.
Compare when the user asks to diff two def files or understand what changed between configurations.

Generate

Load references/generate-workflow.md and references/script-usage.md.

Follow the detailed Generate workflow in the reference: run preflight, classify supplied requirements, ask one requirements question per turn, build a flat YAML profile, run scripts/generate_def.py, show provenance for generated fields, and offer handoff to hsb-ip-create-top.

When packetizer fields are needed, invoke hsb-ip-packetizer with the known RX count, RX widths, and the user's data-manipulation description. Consume only that skill's packetizer_profile_overlay YAML keys, merge them into the in-progress profile, and continue full-file generation and validation here.

Validate

Load references/script-usage.md. Load references/validation-rules.md only when explaining specific rule IDs or validation behavior.

Steps:

Run bundled script preflight once per session.
Locate the file. If the user pastes content, tell them the generated temporary path before writing, ask for confirmation, use an isolated safe temp path, and clean it up after validation unless they ask to keep it. Otherwise use the provided path.
Run <PY> scripts/validate_def.py <path> --json and do not reimplement validation in context.
Group findings by severity: errors, warnings, then info. For each error, cite rule ID, line number, and macro when available.
Always surface footgun warnings, especially HD-W3xx silent-fallback warnings.
If clean, confirm the inferred archetype and IP version, then suggest the likely next check or handoff.

Explain / Reason

Load only the reference needed for the question:

Question type	Reference
Macro semantics or legal values	`references/macro-reference.md`
Validation rule behavior	`references/validation-rules.md`
Macro-driven port effects	`references/top-port-map.md`
`init_reg[]` and `N_INIT_REG`	`references/init-reg-cookbook.md`
Advanced macros	`references/advanced-macros.md`
Example legal configurations	`references/archetypes.md`

For grounded legality questions, run preflight and prefer validating a concrete file or minimal synthetic file with scripts/validate_def.py over hand reasoning. Cite RTL line ranges from references when explaining why a rule exists.

Compare

Load references/script-usage.md, run preflight, then use <PY> scripts/compare_defs.py <a.svh> <b.svh> [--json|--text]. Summarize semantic differences, not whitespace or comment-only changes.

Limitations

Do not generate FPGA_top.sv; use hsb-ip-create-top after the defs file validates.
Do not derive packetizer-only field sets here when the packetizer behavior is underspecified; delegate that slice to hsb-ip-packetizer.
Do not treat bundled archetypes or corpus metadata as norms. They are examples and maintenance metadata, not defaults.
Do not silently accept unknown macros as validated HSB IP behavior unless live source or references document them.

Troubleshooting

Script preflight fails: report the missing Python or PyYAML requirement and stop before generation or validation.
Validation reports errors: group by severity, cite rule ID and line, and fix the defs file before offering top-level handoff.
Validation reports HD-W3xx warnings: surface them even when there are no errors because they describe silent RTL fallback risks.
Unknown macro appears: treat it as project-specific unless live HSB IP source or bundled references document it.

Available Scripts

Use <PY> selected during preflight from references/script-usage.md for every command.

Script	Purpose	Arguments
`scripts/generate_def.py`	Generate `HOLOLINK_def.svh` from an archetype and/or YAML/JSON profile; validates before writing	`--profile <path>`, `--archetype <slug>`, `-o <output>`, optional `--allow-random-uuid` compatibility flag
`scripts/validate_def.py`	Validate a `HOLOLINK_def.svh` and emit JSON or text findings	`<path/to/HOLOLINK_def.svh>`, optional `--json` or `--text`, optional `--ip-source <root>`
`scripts/compare_defs.py`	Compare two def files semantically, ignoring whitespace/comment-only changes	`<a.svh> <b.svh>`, optional `--json` or `--text`
`scripts/build_corpus_metadata.py`	Maintenance helper to rebuild anonymized corpus metadata; do not run during normal user workflows	`<path1> [<path2> ...]`

Bundled Resources

Resource	Use
`references/generate-workflow.md`	Detailed Generate workflow, requirement order, question style, and per-topic prompt guidance
`references/script-usage.md`	Preflight, command forms, and `run_script()` examples for bundled scripts
`references/macro-reference.md`	Wrapper requirement, macro semantics, legal constraints, and RTL citations
`references/validation-rules.md`	Rule catalog for validator findings
`references/archetypes.md`	Illustrative legal configurations; never treat as templates or frequency guidance
`references/init-reg-cookbook.md`	Boot-time APB write sequence patterns and address conventions
`references/top-port-map.md`	Macro-to-`HOLOLINK_top` port effects
`references/advanced-macros.md`	`SYNC_CLK_HIF_APB`, `SYNC_CLK_HIF_PTP`, `PERI_RAM_DEPTH`, and `DISABLE_COE`
`assets/metadata/corpus.json`, `assets/metadata/corpus-stats.json`	Maintenance metadata only; do not cite corpus counts as user guidance
`scripts/generate_def.py`	Generate a def file from a profile
`scripts/validate_def.py`	Validate a def file and emit JSON/text findings
`scripts/compare_defs.py`	Compare two def files semantically

Examples

Use hsb-ip-def to generate a HOLOLINK_def.svh for a new HSB board. Treat as Generate, run script preflight, classify supplied requirements, ask one requirement question per turn, and run scripts/generate_def.py only after the profile is confirmed.
Use hsb-ip-def to validate my existing HOLOLINK_def.svh and tell me whether any warnings are important. Treat as Validate, ask for or locate the file, run scripts/validate_def.py <path> --json, group findings by errors, warnings, and info, and always surface HD-W3xx footgun warnings.
Use hsb-ip-def to explain whether HOST_WIDTH=512 and PTP_CLK_FREQ=90_000_000 is legal. Treat as Explain / Reason, prefer a concrete validator-backed check over hand reasoning, and load only the macro or validation reference needed to explain the result.

Files

ATTRIBUTION.mdAdded by AutoGineer895 B
BENCHMARK.md3.4 KiB
LICENSELicence file added by AutoGineer11.2 KiB
README.md5.0 KiB
SKILL.md11.3 KiB
assets/metadata/corpus-stats.json5.3 KiB
assets/metadata/corpus.json16.9 KiB
evals/evals.json4.4 KiB
references/advanced-macros.md4.7 KiB
references/archetypes.md22.3 KiB
references/generate-workflow.md25.1 KiB
references/init-reg-cookbook.md5.7 KiB
references/macro-reference.md29.8 KiB
references/script-usage.md3.1 KiB
references/top-port-map.md10.2 KiB
references/validation-rules.md14.8 KiB
scripts/build_corpus_metadata.pyScript7.5 KiB
scripts/compare_defs.pyScript6.0 KiB
scripts/generate_def.pyScript8.6 KiB
scripts/lib/__init__.pyScript0 B
scripts/lib/emitter.pyScript25.7 KiB
scripts/lib/parser.pyScript22.3 KiB
scripts/lib/rules.pyScript29.1 KiB
scripts/validate_def.pyScript5.6 KiB
skill-card.md4.5 KiB
skill.oms.sig8.9 KiB

evals/evals.json

[
  {
    "id": "hsb-ip-def-001",
    "question": "Use hsb-ip-def to generate a HOLOLINK_def.svh for a new HSB board. I know the sensor count and host interface, but I need help turning the design requirements into the def file.",
    "expected_skill": "hsb-ip-def",
    "ground_truth": "The agent reads the hsb-ip-def SKILL.md, recognizes this as Generate, runs bundled-tool preflight before design questioning, asks one requirements question per turn, avoids silently defaulting macros, uses sensor-agnostic language, and plans to run generate_def.py after the profile is fully confirmed.",
    "expected_behavior": [
      "The agent reads hsb-ip-def/SKILL.md before taking action",
      "The agent recognizes the request as the Generate workflow",
      "The agent verifies generate_def.py, validate_def.py, compare_defs.py, Python 3.9+, and PyYAML before continuing",
      "The agent asks one design-requirement question per turn",
      "The agent does not silently choose macro defaults",
      "The agent uses sensor-agnostic language unless the user identifies a camera-specific design",
      "The agent plans to run scripts/generate_def.py with the selected Python interpreter after the profile is complete"
    ]
  },
  {
    "id": "hsb-ip-def-002",
    "question": "Use hsb-ip-def to validate my existing HOLOLINK_def.svh and tell me whether any warnings are important.",
    "expected_skill": "hsb-ip-def",
    "ground_truth": "The agent reads the hsb-ip-def SKILL.md, recognizes this as Validate, runs bundled-tool preflight, asks for or locates the defs file, runs validate_def.py with --json, groups findings by severity, and surfaces HD-W3xx footgun warnings even if the user asks only about errors.",
    "expected_behavior": [
      "The agent reads hsb-ip-def/SKILL.md before taking action",
      "The agent recognizes the request as the Validate workflow",
      "The agent runs bundled-tool preflight before validation",
      "The agent asks for the file path or uses pasted content instead of inventing a path",
      "The agent runs scripts/validate_def.py with --json through the selected Python interpreter",
      "The agent groups findings as errors, warnings, and info",
      "The agent always surfaces HD-W3xx footgun warnings"
    ]
  },
  {
    "id": "hsb-ip-def-003",
    "question": "Use hsb-ip-def to explain whether HOST_WIDTH=512 and PTP_CLK_FREQ=90_000_000 is legal for my HOLOLINK_def.svh.",
    "expected_skill": "hsb-ip-def",
    "ground_truth": "The agent reads the hsb-ip-def SKILL.md, recognizes this as Explain/Reason, uses validation scripts for legality rather than reasoning only by hand, loads validation or macro references only as needed, and explains that PTP_CLK_FREQ must be within the documented 95-105 MHz band if validation flags it.",
    "expected_behavior": [
      "The agent reads hsb-ip-def/SKILL.md before answering",
      "The agent recognizes the request as an Explain/Reason workflow",
      "The agent runs preflight if script-backed validation is needed",
      "The agent prefers constructing or validating a concrete file with scripts/validate_def.py for legality checks",
      "The agent loads references/validation-rules.md or references/macro-reference.md only as needed",
      "The agent does not rely on undocumented typical-value claims"
    ]
  },
  {
    "id": "hsb-ip-def-004",
    "question": "Use hsb-ip-def to generate a HOLOLINK_def.svh for a board with two host interfaces and one Sensor TX interface. Help me fill in any missing requirements.",
    "expected_skill": "hsb-ip-def",
    "ground_truth": "The agent reads the hsb-ip-def SKILL.md, recognizes this as Generate, treats HOST_WIDTH as one scalar shared by all host interfaces, does not ask whether host widths are the same or different, and prompts for SIF_TX_BUF_SIZE when Sensor TX is enabled before generating the file.",
    "expected_behavior": [
      "The agent reads hsb-ip-def/SKILL.md before taking action",
      "The agent recognizes the request as the Generate workflow",
      "The agent treats HOST_WIDTH as one shared scalar for every HOST_IF_INST interface",
      "The agent does not ask whether host interfaces have the same or different host widths",
      "The agent asks for SIF_TX_BUF_SIZE when one or more Sensor TX interfaces are enabled",
      "The agent records sif_tx_buf_size as a list of TX-width-element FIFO depths whose length matches SENSOR_TX_IF_INST",
      "The agent does not silently use the 2048-element TX FIFO default without user confirmation"
    ]
  }
]

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

The author says: Targets HSB IP rev 16'h2604; backward-compatible with 16'h2603 (the public release rev). Prefer live HSB IP source when available; warn on unknown revisions. Requires Python 3.9+ with PyYAML for the generator.

Security

What our scanner noticed· Medium risk

Large base64-encoded blobs
Instructions that use the network
Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Holoscan Team

Publisher

NVIDIA (Official)

Distributed by

NVIDIA

Source

NVIDIA/skills · skills/hsb-ip-def · commit fce3cca

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE-APACHE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by Holoscan Team or NVIDIA.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download hsb-ip-def.zip