phoebus_os/scripts/generate-nvidia-devices.py
Phoebus b4a6b5df80
Some checks are pending
ci / test (push) Waiting to run
feat(nvidia): hardware-driven driver policy, installed integration and live payload
- resolve the NVIDIA branch and kernel-module flavor from PCI device IDs
  (Turing+ open modules; Maxwell/Pascal/Volta proprietary, masked below 595;
  Fermi/Kepler fall back to nouveau, reported; unknown IDs reported)
- capture pci_id/pci_address in the probe; drive VIDEO_CARDS, package.use,
  package.accept_keywords, package.mask, modprobe.d and dracut from the plan,
  preserving hybrid Intel/AMD
- add the nvidia_drivers install stage (after the kernel, before boot) that
  emerges the driver, regenerates the initramfs, records /etc/phoebus/nvidia and
  fails the install on failure; sys update rebuilds modules and the initramfs
- refuse AI changes to x11-drivers/nvidia-drivers
- live ISO: signed non-free components, stable-kernel pin (testing 7.2 breaks
  the 550 driver), DKMS build for the exact kernel, gated pre-greetd load,
  fail-safe entry, gpu-report, and a --verify-live-nvidia build gate that runs
  on cached rootfs builds and fails on any missing component
- docs: ADR 0012, STATUS/CHANGELOG/HANDOFF, live README
- also carries the pending OpenCode model-variant/streaming changes and fixes
  the GUI bridge install thread join that could hang
2026-09-22 21:53:28 -07:00

173 lines
6.6 KiB
Bash

#!/usr/bin/env python3
"""Generate phoebus-core's NVIDIA PCI device-ID -> generation table.
The table is derived from the public PCI ID database (`pci.ids`), vendor
`10de` (NVIDIA). Each entry's NVIDIA chip codename prefix (for example
`TU117`, `GA104`, `AD102`, `GB202`) determines the hardware generation. Only
display-class device IDs are ever looked up at runtime (the probe feeds the
classifier the IDs of `VGA compatible controller` / `3D controller` /
`Display controller` devices), so stray non-display entries in the database
are harmless.
Usage:
scripts/generate-nvidia-devices.py [pci.ids] > nvidia_devices.rs
With no argument the database is fetched from <https://pci-ids.ucw.cz/>.
The generated file is committed; it is never generated during a build.
"""
from __future__ import annotations
import hashlib
import re
import sys
import urllib.request
PCI_IDS_URL = "https://pci-ids.ucw.cz/v2.2/pci.ids"
# Codename prefix (first token of the PCI name) -> generation. The prefixes
# are NVIDIA's public architecture codenames (Tegra parts share the same
# families and are mapped accordingly). Ordered so the longest/most specific
# prefixes are matched first.
GENERATIONS: list[tuple[str, str]] = [
("Fermi", "GF"),
("Kepler", "GK"),
("Maxwell", "GM"),
("Pascal", "GP"),
("Volta", "GV"),
("Turing", "TU"),
("Ampere", "GA"),
("Ada", "AD"),
("Hopper", "GH"),
("Blackwell", "GB"),
]
CODENAME_RE = re.compile(r"^([A-Z]{2}\d{2,3}[A-Z]?)\b")
def fetch(url: str) -> bytes:
with urllib.request.urlopen(url, timeout=60) as resp: # noqa: S310
return resp.read()
def nvidia_devices(text: str) -> list[tuple[int, str]]:
lines = text.splitlines()
start = None
for i, line in enumerate(lines):
if re.match(r"^10de\s", line):
start = i
break
if start is None:
raise SystemExit("NVIDIA vendor (10de) not found in pci.ids")
devices: list[tuple[int, str]] = []
for line in lines[start + 1 :]:
if re.match(r"^[0-9a-fA-F]{4}\s", line):
break
m = re.match(r"^\t([0-9a-fA-F]{4})\s+(.*)", line)
if m:
devices.append((int(m.group(1), 16), m.group(2).strip()))
return devices
def generation_for(name: str) -> str | None:
m = CODENAME_RE.match(name)
if not m:
return None
codename = m.group(1)
for generation, prefix in GENERATIONS:
if codename.startswith(prefix):
return generation
return None
def main() -> int:
if len(sys.argv) > 1:
data = open(sys.argv[1], "rb").read()
source = sys.argv[1]
else:
data = fetch(PCI_IDS_URL)
source = PCI_IDS_URL
sha = hashlib.sha256(data).hexdigest()
devices = nvidia_devices(data.decode("utf-8", "replace"))
buckets: dict[str, set[int]] = {}
for device_id, name in devices:
generation = generation_for(name)
if generation:
buckets.setdefault(generation, set()).add(device_id)
# Detect an ID that would classify as two generations; the database does
# not normally contain one, and a duplicate means the codename rule is
# ambiguous and must be fixed here rather than silently resolved.
seen: dict[int, str] = {}
for generation, ids in buckets.items():
for device_id in ids:
if device_id in seen:
raise SystemExit(
f"device {device_id:#06x} classified as both "
f"{seen[device_id]} and {generation}"
)
seen[device_id] = generation
out = []
out.append("//! NVIDIA PCI device-ID classification table.")
out.append("//!")
out.append("//! GENERATED FILE - do not edit by hand. Regenerate with")
out.append("//! `scripts/generate-nvidia-devices.py`. The table is derived")
out.append("//! from the public PCI ID database (`pci.ids`, NVIDIA vendor `10de`)")
out.append("//! by mapping each device's NVIDIA chip codename to its generation.")
out.append("//!")
out.append(f"//! Source: {source}")
out.append(f"//! Source SHA-256: {sha}")
out.append("")
out.append("use super::nvidia::NvidiaGeneration;")
out.append("")
out.append("/// The PCI ID database revision this table was generated from.")
out.append(f'pub const SOURCE_SHA256: &str = "{sha}";')
out.append("")
out.append("/// Classify an NVIDIA PCI device ID (the `device` half of the")
out.append("/// `vendor:device` pair, fully qualified).")
out.append("///")
out.append("/// `None` means the database has no recognised NVIDIA chip codename for")
out.append("/// the device: it is reported as unknown and never claimed as supported.")
out.append("pub fn generation_for_device(device_id: u16) -> Option<NvidiaGeneration> {")
out.append(" use NvidiaGeneration::*;")
out.append(" match device_id {")
for generation, _ in GENERATIONS:
ids = sorted(buckets.get(generation, set()))
if not ids:
continue
joined = " | ".join(f"0x{i:04x}" for i in ids)
out.append(f" {joined} => Some({generation}),")
out.append(" _ => None,")
out.append(" }")
out.append("}")
out.append("")
out.append("#[cfg(test)]")
out.append("mod tests {")
out.append(" use super::*;")
out.append("")
out.append(" #[test]")
out.append(" fn representative_devices_classify() {")
out.append(" assert_eq!(generation_for_device(0x1380), Some(NvidiaGeneration::Maxwell));")
out.append(" assert_eq!(generation_for_device(0x1b81), Some(NvidiaGeneration::Pascal));")
out.append(" assert_eq!(generation_for_device(0x1d81), Some(NvidiaGeneration::Volta));")
out.append(" assert_eq!(generation_for_device(0x1e04), Some(NvidiaGeneration::Turing));")
out.append(" assert_eq!(generation_for_device(0x2482), Some(NvidiaGeneration::Ampere));")
out.append(" assert_eq!(generation_for_device(0x2684), Some(NvidiaGeneration::Ada));")
out.append(" assert_eq!(generation_for_device(0x2330), Some(NvidiaGeneration::Hopper));")
out.append(" assert_eq!(generation_for_device(0x2b85), Some(NvidiaGeneration::Blackwell));")
out.append(" assert_eq!(generation_for_device(0x0fc0), Some(NvidiaGeneration::Kepler));")
out.append(" }")
out.append("")
out.append(" #[test]")
out.append(" fn unknown_device_is_not_classified() {")
out.append(" assert_eq!(generation_for_device(0x0000), None);")
out.append(" }")
out.append("}")
sys.stdout.write("\n".join(out) + "\n")
return 0
if __name__ == "__main__":
raise SystemExit(main())