From 4332b302719a97738e4b9da76bb5226bdd1da5ae Mon Sep 17 00:00:00 2001 From: Sinan KARAKAYA Date: Tue, 21 Apr 2026 15:44:56 +0200 Subject: [PATCH 1/6] feat(hardware_info): Add support for Qualcomm NPU devices and FastRPC bus Introduce the FastRPC bus type and restrict it to NPU devices. Add Qualcomm hardware detection by checking for fastrpc nodes. Include NodeGlob field for NPU devices and update disk info gathering to silently skip nonexistent directories. Signed-off-by: Sinan KARAKAYA --- pkg/engines/busses.go | 31 +++++++ pkg/engines/busses_test.go | 9 ++ pkg/engines/devices_test.go | 23 +++++ pkg/engines/types.go | 4 +- pkg/hardware_info/disk/disk_info.go | 9 ++ pkg/hardware_info/hardware-info.go | 24 ++++++ pkg/hardware_info/qualcomm/qualcomm.go | 94 +++++++++++++++++++++ pkg/hardware_info/qualcomm/qualcomm_test.go | 86 +++++++++++++++++++ pkg/selector/fastrpc/fastrpc.go | 58 +++++++++++++ pkg/selector/fastrpc/fastrpc_test.go | 50 +++++++++++ pkg/selector/fastrpc_test.go | 52 ++++++++++++ pkg/selector/select_stack.go | 19 +++++ pkg/types/detected_devices.go | 12 +++ pkg/types/hw_info.go | 2 + 14 files changed, 471 insertions(+), 2 deletions(-) create mode 100644 pkg/hardware_info/qualcomm/qualcomm.go create mode 100644 pkg/hardware_info/qualcomm/qualcomm_test.go create mode 100644 pkg/selector/fastrpc/fastrpc.go create mode 100644 pkg/selector/fastrpc/fastrpc_test.go create mode 100644 pkg/selector/fastrpc_test.go create mode 100644 pkg/types/detected_devices.go diff --git a/pkg/engines/busses.go b/pkg/engines/busses.go index 1f2b2869..46f79c80 100644 --- a/pkg/engines/busses.go +++ b/pkg/engines/busses.go @@ -12,6 +12,8 @@ func (device Device) validateBus(extraFields []string) error { return device.validatePci(extraFields) case "usb": return device.validateUsb(extraFields) + case "fastrpc": + return device.validateFastRpc(extraFields) case "": // default to pci bus return device.validatePci(extraFields) default: @@ -49,3 +51,32 @@ func (device Device) validatePci(extraFields []string) error { return nil } + +func (device Device) validateFastRpc(extraFields []string) error { + if device.Type != "" && device.Type != "npu" { + return fmt.Errorf("fastrpc bus only supports npu devices") + } + + validFields := []string{ + "Type", + "Bus", + "NodeGlob", + "SnapConnections", + } + validFields = append(validFields, extraFields...) + + t := reflect.TypeOf(device) + v := reflect.ValueOf(device) + + for i := 0; i < t.NumField(); i++ { + fieldName := t.Field(i).Name + fieldValue := v.FieldByName(fieldName) + if fieldValue.IsValid() && !fieldValue.IsZero() { + if !slices.Contains(validFields, fieldName) { + return fmt.Errorf("fastrpc: invalid field: %s", fieldName) + } + } + } + + return nil +} diff --git a/pkg/engines/busses_test.go b/pkg/engines/busses_test.go index a8abd686..6155aa99 100644 --- a/pkg/engines/busses_test.go +++ b/pkg/engines/busses_test.go @@ -42,4 +42,13 @@ func TestDeviceBus(t *testing.T) { } t.Log(err) }) + + t.Run("FastRPC bus with non-NPU type", func(t *testing.T) { + device.Bus = "fastrpc" + err := device.validate() + if err == nil { + t.Fatal("FastRPC bus should be invalid for GPU type") + } + t.Log(err) + }) } diff --git a/pkg/engines/devices_test.go b/pkg/engines/devices_test.go index 168b3565..5531036b 100644 --- a/pkg/engines/devices_test.go +++ b/pkg/engines/devices_test.go @@ -130,6 +130,29 @@ func TestDeviceNpu(t *testing.T) { } t.Log(err) }) + + t.Run("NPU fastrpc valid fields", func(t *testing.T) { + device = Device{Type: "npu", Bus: "fastrpc"} + nodeGlob := "/dev/fastrpc-cdsp*" + device.NodeGlob = &nodeGlob + + err := device.validate() + if err != nil { + t.Fatalf("NPU fastrpc fields should be valid: %v", err) + } + }) + + t.Run("NPU fastrpc invalid fields", func(t *testing.T) { + device = Device{Type: "npu", Bus: "fastrpc"} + hexValue := types.HexInt(0xAA) + device.VendorId = &hexValue + + err := device.validate() + if err == nil { + t.Fatal("NPU fastrpc fields should be invalid") + } + t.Log(err) + }) } func TestDeviceTypeless(t *testing.T) { diff --git a/pkg/engines/types.go b/pkg/engines/types.go index 803c120a..05c7da14 100644 --- a/pkg/engines/types.go +++ b/pkg/engines/types.go @@ -45,7 +45,7 @@ type Devices struct { type Device struct { // General Type string `yaml:"type,omitempty" json:"type,omitempty"` // cpu, gpu, npu or nil - Bus string `yaml:"bus,omitempty" json:"bus,omitempty"` // pci, usb or nil + Bus string `yaml:"bus,omitempty" json:"bus,omitempty"` // pci, usb, fastrpc or nil // CPUs Architecture *string `yaml:"architecture,omitempty" json:"architecture,omitempty"` @@ -69,7 +69,7 @@ type Device struct { ComputeCapability *string `yaml:"compute-capability,omitempty" json:"compute-capability,omitempty"` // NPU - // no additional properties for now + NodeGlob *string `yaml:"node-glob,omitempty" json:"node-glob,omitempty"` // Drivers SnapConnections []string `yaml:"snap-connections,omitempty" json:"snap-connections,omitempty"` diff --git a/pkg/hardware_info/disk/disk_info.go b/pkg/hardware_info/disk/disk_info.go index 1781be2a..7858efde 100644 --- a/pkg/hardware_info/disk/disk_info.go +++ b/pkg/hardware_info/disk/disk_info.go @@ -2,6 +2,7 @@ package disk import ( "fmt" + "os" "github.com/canonical/inference-snaps-cli/pkg/constants" "github.com/canonical/inference-snaps-cli/pkg/types" @@ -16,6 +17,14 @@ func Info() (map[string]types.DirStats, error) { var info = make(map[string]types.DirStats) for _, dir := range directories { + // Skip directories that don't exist + if _, err := os.Stat(dir); err != nil { + if os.IsNotExist(err) { + continue + } + return nil, fmt.Errorf("checking directory %s: %v", dir, err) + } + dirInfo, err := statFs(dir) if err != nil { return nil, fmt.Errorf("getting directory info for %s: %v", dir, err) diff --git a/pkg/hardware_info/hardware-info.go b/pkg/hardware_info/hardware-info.go index b6e9d278..a28b01ed 100644 --- a/pkg/hardware_info/hardware-info.go +++ b/pkg/hardware_info/hardware-info.go @@ -4,12 +4,14 @@ import ( "encoding/json" "fmt" "os" + "strings" "testing" "github.com/canonical/inference-snaps-cli/pkg/hardware_info/cpu" "github.com/canonical/inference-snaps-cli/pkg/hardware_info/disk" "github.com/canonical/inference-snaps-cli/pkg/hardware_info/memory" "github.com/canonical/inference-snaps-cli/pkg/hardware_info/pci" + "github.com/canonical/inference-snaps-cli/pkg/hardware_info/qualcomm" "github.com/canonical/inference-snaps-cli/pkg/types" ) @@ -40,6 +42,13 @@ func Get(friendlyNames bool) (*types.HwInfo, error) { } hwInfo.PciDevices = pciDevices + platforms, devices, err := qualcomm.Info() + if err != nil { + return nil, fmt.Errorf("getting qualcomm devices: %v", err) + } + hwInfo.Platforms = platforms + hwInfo.Devices = devices + return &hwInfo, nil } @@ -97,6 +106,21 @@ func GetFromRawData(t *testing.T, device string, friendlyNames bool, testDir str } hwInfo.PciDevices = pciDevices + fastrpcNodesFile := devicePath + "fastrpc-nodes.txt" + if _, err := os.Stat(fastrpcNodesFile); err == nil { + nodesData, err := os.ReadFile(fastrpcNodesFile) + if err != nil { + t.Fatal(err) + } + + nodes := strings.Fields(string(nodesData)) + platforms, devices := qualcomm.DetectFromNodes(nodes) + hwInfo.Platforms = platforms + hwInfo.Devices = devices + } else if !os.IsNotExist(err) { + t.Fatalf("error checking file '%s': %v\n", fastrpcNodesFile, err) + } + // Additional properties - we append these directly from a file, as we can not run the vendor specific tools on the machine addPropsFile := devicePath + "additional-properties.json" _, err = os.Stat(addPropsFile) diff --git a/pkg/hardware_info/qualcomm/qualcomm.go b/pkg/hardware_info/qualcomm/qualcomm.go new file mode 100644 index 00000000..27ca2742 --- /dev/null +++ b/pkg/hardware_info/qualcomm/qualcomm.go @@ -0,0 +1,94 @@ +package qualcomm + +import ( + "fmt" + "path/filepath" + "sort" + "strings" + + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +var devRoot = "/dev" + +func Info() ([]types.PlatformInfo, []types.DetectedDevice, error) { + fastrpcNodes, err := globSorted(filepath.Join(devRoot, "fastrpc-*")) + if err != nil { + return nil, nil, fmt.Errorf("detecting fastrpc nodes: %v", err) + } + + cdspNodes, err := globSorted(filepath.Join(devRoot, "fastrpc-cdsp*")) + if err != nil { + return nil, nil, fmt.Errorf("detecting cdsp fastrpc nodes: %v", err) + } + + var platforms []types.PlatformInfo + if len(fastrpcNodes) > 0 { + platforms = append(platforms, types.PlatformInfo{ + Vendor: "qualcomm", + Name: "dragonwing", + }) + } + + var devices []types.DetectedDevice + if len(cdspNodes) > 0 { + devices = append(devices, types.DetectedDevice{ + Type: "npu", + Bus: "fastrpc", + Nodes: cdspNodes, + }) + } + + return platforms, devices, nil +} + +func DetectFromNodes(nodes []string) ([]types.PlatformInfo, []types.DetectedDevice) { + var fastrpcNodes []string + var cdspNodes []string + + for _, node := range nodes { + node = strings.TrimSpace(node) + if node == "" { + continue + } + + base := filepath.Base(node) + if strings.HasPrefix(base, "fastrpc-") { + fastrpcNodes = append(fastrpcNodes, node) + } + if strings.HasPrefix(base, "fastrpc-cdsp") { + cdspNodes = append(cdspNodes, node) + } + } + + sort.Strings(fastrpcNodes) + sort.Strings(cdspNodes) + + var platforms []types.PlatformInfo + if len(fastrpcNodes) > 0 { + platforms = append(platforms, types.PlatformInfo{ + Vendor: "qualcomm", + Name: "dragonwing", + }) + } + + var devices []types.DetectedDevice + if len(cdspNodes) > 0 { + devices = append(devices, types.DetectedDevice{ + Type: "npu", + Bus: "fastrpc", + Nodes: cdspNodes, + }) + } + + return platforms, devices +} + +func globSorted(pattern string) ([]string, error) { + matches, err := filepath.Glob(pattern) + if err != nil { + return nil, err + } + sort.Strings(matches) + return matches, nil +} diff --git a/pkg/hardware_info/qualcomm/qualcomm_test.go b/pkg/hardware_info/qualcomm/qualcomm_test.go new file mode 100644 index 00000000..cf7914c1 --- /dev/null +++ b/pkg/hardware_info/qualcomm/qualcomm_test.go @@ -0,0 +1,86 @@ +package qualcomm + +import ( + "os" + "path/filepath" + "reflect" + "testing" + + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +func TestInfo(t *testing.T) { + tmp := t.TempDir() + originalRoot := devRoot + devRoot = tmp + t.Cleanup(func() { + devRoot = originalRoot + }) + + _, err := os.Create(filepath.Join(tmp, "fastrpc-adsp-secure")) + if err != nil { + t.Fatal(err) + } + _, err = os.Create(filepath.Join(tmp, "fastrpc-cdsp")) + if err != nil { + t.Fatal(err) + } + _, err = os.Create(filepath.Join(tmp, "fastrpc-cdsp1")) + if err != nil { + t.Fatal(err) + } + + platforms, devices, err := Info() + if err != nil { + t.Fatal(err) + } + + expectedPlatforms := []types.PlatformInfo{{ + Vendor: "qualcomm", + Name: "dragonwing", + }} + if !reflect.DeepEqual(platforms, expectedPlatforms) { + t.Fatalf("platforms=%+v expected=%+v", platforms, expectedPlatforms) + } + + expectedDevices := []types.DetectedDevice{{ + Type: "npu", + Bus: "fastrpc", + Nodes: []string{ + filepath.Join(tmp, "fastrpc-cdsp"), + filepath.Join(tmp, "fastrpc-cdsp1"), + }, + }} + if !reflect.DeepEqual(devices, expectedDevices) { + t.Fatalf("devices=%+v expected=%+v", devices, expectedDevices) + } +} + +func TestDetectFromNodes(t *testing.T) { + nodes := []string{ + "/dev/fastrpc-cdsp1-secure", + "/dev/fastrpc-adsp", + "/dev/something-else", + "/dev/fastrpc-cdsp", + } + + platforms, devices := DetectFromNodes(nodes) + if len(platforms) != 1 { + t.Fatalf("expected 1 platform, got %d", len(platforms)) + } + if platforms[0].Vendor != "qualcomm" || platforms[0].Name != "dragonwing" { + t.Fatalf("unexpected platform %+v", platforms[0]) + } + + if len(devices) != 1 { + t.Fatalf("expected 1 device, got %d", len(devices)) + } + if devices[0].Type != "npu" || devices[0].Bus != "fastrpc" { + t.Fatalf("unexpected device %+v", devices[0]) + } + + expectedNodes := []string{"/dev/fastrpc-cdsp", "/dev/fastrpc-cdsp1-secure"} + if !reflect.DeepEqual(devices[0].Nodes, expectedNodes) { + t.Fatalf("nodes=%v expected=%v", devices[0].Nodes, expectedNodes) + } +} diff --git a/pkg/selector/fastrpc/fastrpc.go b/pkg/selector/fastrpc/fastrpc.go new file mode 100644 index 00000000..c3823311 --- /dev/null +++ b/pkg/selector/fastrpc/fastrpc.go @@ -0,0 +1,58 @@ +package fastrpc + +import ( + "fmt" + "path/filepath" + "testing" + + "github.com/canonical/go-snapctl" + "github.com/canonical/inference-snaps-cli/pkg/engines" + "github.com/canonical/inference-snaps-cli/pkg/selector/weights" + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +const defaultNpuNodeGlob = "/dev/fastrpc-cdsp*" + +func Match(manifestDevice engines.Device, hostDevices []types.DetectedDevice) (int, []string) { + nodeGlob := defaultNpuNodeGlob + if manifestDevice.NodeGlob != nil { + nodeGlob = *manifestDevice.NodeGlob + } + + for _, hostDevice := range hostDevices { + if hostDevice.Bus != "fastrpc" { + continue + } + if manifestDevice.Type != "" && hostDevice.Type != manifestDevice.Type { + continue + } + + for _, node := range hostDevice.Nodes { + matched, err := filepath.Match(nodeGlob, node) + if err != nil { + return 0, []string{fmt.Sprintf("invalid node-glob %q: %v", nodeGlob, err)} + } + if !matched { + continue + } + + score := weights.PciDevice + weights.PciDeviceType + for _, connection := range manifestDevice.SnapConnections { + if testing.Testing() { + continue + } + connected, err := snapctl.IsConnected(connection).Run() + if err != nil { + return 0, []string{fmt.Sprintf("checking snap connection %q: %v", connection, err)} + } + if !connected { + return 0, []string{fmt.Sprintf("%q is not connected", connection)} + } + } + + return score, nil + } + } + + return 0, []string{fmt.Sprintf("device node matching %q not found", nodeGlob)} +} diff --git a/pkg/selector/fastrpc/fastrpc_test.go b/pkg/selector/fastrpc/fastrpc_test.go new file mode 100644 index 00000000..33065305 --- /dev/null +++ b/pkg/selector/fastrpc/fastrpc_test.go @@ -0,0 +1,50 @@ +package fastrpc + +import ( + "testing" + + "github.com/canonical/inference-snaps-cli/pkg/engines" + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +func TestMatch(t *testing.T) { + hostDevices := []types.DetectedDevice{ + { + Type: "npu", + Bus: "fastrpc", + Nodes: []string{ + "/dev/fastrpc-cdsp", + "/dev/fastrpc-cdsp1-secure", + }, + }, + } + + t.Run("default pattern", func(t *testing.T) { + device := engines.Device{Type: "npu", Bus: "fastrpc"} + score, issues := Match(device, hostDevices) + if score == 0 || len(issues) > 0 { + t.Fatalf("expected a positive score with no issues, score=%d issues=%v", score, issues) + } + }) + + t.Run("custom node glob", func(t *testing.T) { + nodeGlob := "/dev/fastrpc-cdsp1*" + device := engines.Device{Type: "npu", Bus: "fastrpc", NodeGlob: &nodeGlob} + score, issues := Match(device, hostDevices) + if score == 0 || len(issues) > 0 { + t.Fatalf("expected a positive score with no issues, score=%d issues=%v", score, issues) + } + }) + + t.Run("no matching node", func(t *testing.T) { + nodeGlob := "/dev/fastrpc-gdsp*" + device := engines.Device{Type: "npu", Bus: "fastrpc", NodeGlob: &nodeGlob} + score, issues := Match(device, hostDevices) + if score != 0 { + t.Fatalf("expected score=0, got %d", score) + } + if len(issues) == 0 { + t.Fatal("expected compatibility issues") + } + }) +} diff --git a/pkg/selector/fastrpc_test.go b/pkg/selector/fastrpc_test.go new file mode 100644 index 00000000..dd2132ac --- /dev/null +++ b/pkg/selector/fastrpc_test.go @@ -0,0 +1,52 @@ +package selector + +import ( + "testing" + + "github.com/canonical/inference-snaps-cli/pkg/engines" + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +func TestFastRpcNpuSelection(t *testing.T) { + hwInfo := &types.HwInfo{ + Memory: types.MemoryInfo{TotalRam: 8 * 1024 * 1024 * 1024}, + Disk: map[string]types.DirStats{ + "/var/lib/snapd/snaps": { + Avail: 20 * 1024 * 1024 * 1024, + }, + }, + Devices: []types.DetectedDevice{ + { + Type: "npu", + Bus: "fastrpc", + Nodes: []string{ + "/dev/fastrpc-cdsp", + }, + }, + }, + } + + manifest := engines.Manifest{ + Name: "qualcomm-npu", + Description: "qualcomm dragonwing npu", + Vendor: "qualcomm", + Grade: "stable", + Devices: engines.Devices{ + Anyof: []engines.Device{{ + Type: "npu", + Bus: "fastrpc", + }}, + }, + } + + score, report, err := checkEngine(hwInfo, manifest) + if err != nil { + t.Fatal(err) + } + if !report.EngineCompatible() { + t.Fatalf("expected engine to be compatible: %+v", report) + } + if score <= 0 { + t.Fatalf("expected positive score, got %d", score) + } +} diff --git a/pkg/selector/select_stack.go b/pkg/selector/select_stack.go index 671f52c1..bd84a5db 100644 --- a/pkg/selector/select_stack.go +++ b/pkg/selector/select_stack.go @@ -8,6 +8,7 @@ import ( "github.com/canonical/inference-snaps-cli/pkg/constants" "github.com/canonical/inference-snaps-cli/pkg/engines" "github.com/canonical/inference-snaps-cli/pkg/selector/cpu" + "github.com/canonical/inference-snaps-cli/pkg/selector/fastrpc" "github.com/canonical/inference-snaps-cli/pkg/selector/pci" "github.com/canonical/inference-snaps-cli/pkg/types" "github.com/canonical/inference-snaps-cli/pkg/utils" @@ -165,6 +166,15 @@ func scoreDevicesAll(hardwareInfo *types.HwInfo, devices []engines.Device) int { compatible = false devices[i].CompatibilityIssues = append(devices[i].CompatibilityIssues, "usb device matching not implemented") + } else if devices[i].Bus == "fastrpc" { + fastRpcScore, fastRpcIssues := fastrpc.Match(devices[i], hardwareInfo.Devices) + if len(fastRpcIssues) > 0 { + compatible = false + devices[i].CompatibilityIssues = append(devices[i].CompatibilityIssues, fastRpcIssues...) + } else { + compatibilityScore += fastRpcScore + } + } else if devices[i].Bus == "" || devices[i].Bus == "pci" { // Fallback to PCI as default bus pciScore, pciIssues := pci.Match(devices[i], hardwareInfo.PciDevices) @@ -204,6 +214,15 @@ func scoreDevicesAny(hardwareInfo *types.HwInfo, devices []engines.Device) int { compatible = false device.CompatibilityIssues = append(device.CompatibilityIssues, "usb device matching not implemented") + } else if device.Bus == "fastrpc" { + fastRpcScore, fastRpcIssues := fastrpc.Match(device, hardwareInfo.Devices) + if len(fastRpcIssues) > 0 { + devices[i].CompatibilityIssues = append(device.CompatibilityIssues, fastRpcIssues...) + } else { + devicesFound++ + compatibilityScore += fastRpcScore + } + } else if device.Bus == "" || device.Bus == "pci" { // Fallback to PCI as default bus pciScore, pciIssues := pci.Match(device, hardwareInfo.PciDevices) diff --git a/pkg/types/detected_devices.go b/pkg/types/detected_devices.go new file mode 100644 index 00000000..7db5cfc5 --- /dev/null +++ b/pkg/types/detected_devices.go @@ -0,0 +1,12 @@ +package types + +type PlatformInfo struct { + Vendor string `json:"vendor" yaml:"vendor"` + Name string `json:"name" yaml:"name"` +} + +type DetectedDevice struct { + Type string `json:"type" yaml:"type"` + Bus string `json:"bus" yaml:"bus"` + Nodes []string `json:"nodes,omitempty" yaml:"nodes,omitempty"` +} diff --git a/pkg/types/hw_info.go b/pkg/types/hw_info.go index 9548c730..f31b35ba 100644 --- a/pkg/types/hw_info.go +++ b/pkg/types/hw_info.go @@ -5,4 +5,6 @@ type HwInfo struct { Memory MemoryInfo `json:"memory,omitempty" yaml:"memory,omitempty"` Disk map[string]DirStats `json:"disk,omitempty" yaml:"disk,omitempty"` PciDevices []PciDevice `json:"pci,omitempty" yaml:"pci"` + Platforms []PlatformInfo `json:"platforms,omitempty" yaml:"platforms,omitempty"` + Devices []DetectedDevice `json:"devices,omitempty" yaml:"devices,omitempty"` } From f6cb7886ef7471ef13341b5a5b6e1c528e0cd51f Mon Sep 17 00:00:00 2001 From: Sinan KARAKAYA Date: Fri, 24 Apr 2026 16:23:06 +0200 Subject: [PATCH 2/6] refator(hw-detection: Flatted QC NPU nodes, moved Platforms to DetectedDevices Flattened NPU nodes (ADSP, CDSP, GDSP) to be considered as distinct devices rather than relying on DetectedDevice.Nodes. PlatformsInfo was moved from Devices to DetectedDevices, to avoid having to keep a relationship between each devices and their respective platform's metadata. Signed-off-by: Sinan KARAKAYA Co-authored-by: Copilot --- pkg/hardware_info/hardware-info.go | 6 +- pkg/hardware_info/qualcomm/qualcomm.go | 82 +++++++------------ pkg/hardware_info/qualcomm/qualcomm_test.go | 91 ++++++++++++++------- pkg/selector/fastrpc/fastrpc.go | 65 ++++++++++----- pkg/selector/fastrpc/fastrpc_test.go | 16 +++- pkg/selector/fastrpc_test.go | 6 +- pkg/types/detected_devices.go | 3 +- pkg/types/hw_info.go | 1 - 8 files changed, 154 insertions(+), 116 deletions(-) diff --git a/pkg/hardware_info/hardware-info.go b/pkg/hardware_info/hardware-info.go index a28b01ed..7db51d09 100644 --- a/pkg/hardware_info/hardware-info.go +++ b/pkg/hardware_info/hardware-info.go @@ -42,11 +42,10 @@ func Get(friendlyNames bool) (*types.HwInfo, error) { } hwInfo.PciDevices = pciDevices - platforms, devices, err := qualcomm.Info() + devices, err := qualcomm.Info() if err != nil { return nil, fmt.Errorf("getting qualcomm devices: %v", err) } - hwInfo.Platforms = platforms hwInfo.Devices = devices return &hwInfo, nil @@ -114,8 +113,7 @@ func GetFromRawData(t *testing.T, device string, friendlyNames bool, testDir str } nodes := strings.Fields(string(nodesData)) - platforms, devices := qualcomm.DetectFromNodes(nodes) - hwInfo.Platforms = platforms + devices := qualcomm.DetectFromNodes(nodes) hwInfo.Devices = devices } else if !os.IsNotExist(err) { t.Fatalf("error checking file '%s': %v\n", fastrpcNodesFile, err) diff --git a/pkg/hardware_info/qualcomm/qualcomm.go b/pkg/hardware_info/qualcomm/qualcomm.go index 27ca2742..643d4aa7 100644 --- a/pkg/hardware_info/qualcomm/qualcomm.go +++ b/pkg/hardware_info/qualcomm/qualcomm.go @@ -11,40 +11,17 @@ import ( var devRoot = "/dev" -func Info() ([]types.PlatformInfo, []types.DetectedDevice, error) { - fastrpcNodes, err := globSorted(filepath.Join(devRoot, "fastrpc-*")) +func Info() ([]types.DetectedDevice, error) { + nodes, err := globSorted(filepath.Join(devRoot, "fastrpc-*")) if err != nil { - return nil, nil, fmt.Errorf("detecting fastrpc nodes: %v", err) + return nil, fmt.Errorf("detecting fastrpc nodes: %v", err) } - cdspNodes, err := globSorted(filepath.Join(devRoot, "fastrpc-cdsp*")) - if err != nil { - return nil, nil, fmt.Errorf("detecting cdsp fastrpc nodes: %v", err) - } - - var platforms []types.PlatformInfo - if len(fastrpcNodes) > 0 { - platforms = append(platforms, types.PlatformInfo{ - Vendor: "qualcomm", - Name: "dragonwing", - }) - } - - var devices []types.DetectedDevice - if len(cdspNodes) > 0 { - devices = append(devices, types.DetectedDevice{ - Type: "npu", - Bus: "fastrpc", - Nodes: cdspNodes, - }) - } - - return platforms, devices, nil + return DetectFromNodes(nodes), nil } -func DetectFromNodes(nodes []string) ([]types.PlatformInfo, []types.DetectedDevice) { - var fastrpcNodes []string - var cdspNodes []string +func DetectFromNodes(nodes []string) []types.DetectedDevice { + var devices []types.DetectedDevice for _, node := range nodes { node = strings.TrimSpace(node) @@ -53,35 +30,35 @@ func DetectFromNodes(nodes []string) ([]types.PlatformInfo, []types.DetectedDevi } base := filepath.Base(node) - if strings.HasPrefix(base, "fastrpc-") { - fastrpcNodes = append(fastrpcNodes, node) - } - if strings.HasPrefix(base, "fastrpc-cdsp") { - cdspNodes = append(cdspNodes, node) + if !strings.HasPrefix(base, "fastrpc-") { + continue } - } - - sort.Strings(fastrpcNodes) - sort.Strings(cdspNodes) - - var platforms []types.PlatformInfo - if len(fastrpcNodes) > 0 { - platforms = append(platforms, types.PlatformInfo{ - Vendor: "qualcomm", - Name: "dragonwing", - }) - } - var devices []types.DetectedDevice - if len(cdspNodes) > 0 { devices = append(devices, types.DetectedDevice{ - Type: "npu", - Bus: "fastrpc", - Nodes: cdspNodes, + Type: detectNpuType(base), + Bus: "fastrpc", + PlatformInfo: &types.PlatformInfo{ + Vendor: "qualcomm", + Name: node, + SoC: "dragonwing", + }, }) } - return platforms, devices + sort.Slice(devices, func(i, j int) bool { + return devices[i].PlatformInfo.Name < devices[j].PlatformInfo.Name + }) + + return devices +} + +func detectNpuType(nodeBaseName string) string { + const prefix = "fastrpc-" + if strings.HasPrefix(nodeBaseName, prefix) { + suffix := strings.TrimPrefix(nodeBaseName, prefix) + return fmt.Sprintf("NPU - %s", suffix) + } + return "NPU" } func globSorted(pattern string) ([]string, error) { @@ -89,6 +66,7 @@ func globSorted(pattern string) ([]string, error) { if err != nil { return nil, err } + sort.Strings(matches) return matches, nil } diff --git a/pkg/hardware_info/qualcomm/qualcomm_test.go b/pkg/hardware_info/qualcomm/qualcomm_test.go index cf7914c1..820f99fa 100644 --- a/pkg/hardware_info/qualcomm/qualcomm_test.go +++ b/pkg/hardware_info/qualcomm/qualcomm_test.go @@ -30,27 +30,40 @@ func TestInfo(t *testing.T) { t.Fatal(err) } - platforms, devices, err := Info() + devices, err := Info() if err != nil { t.Fatal(err) } - expectedPlatforms := []types.PlatformInfo{{ - Vendor: "qualcomm", - Name: "dragonwing", - }} - if !reflect.DeepEqual(platforms, expectedPlatforms) { - t.Fatalf("platforms=%+v expected=%+v", platforms, expectedPlatforms) - } - - expectedDevices := []types.DetectedDevice{{ - Type: "npu", - Bus: "fastrpc", - Nodes: []string{ - filepath.Join(tmp, "fastrpc-cdsp"), - filepath.Join(tmp, "fastrpc-cdsp1"), + expectedDevices := []types.DetectedDevice{ + { + Type: "NPU - adsp-secure", + Bus: "fastrpc", + PlatformInfo: &types.PlatformInfo{ + Vendor: "qualcomm", + Name: filepath.Join(tmp, "fastrpc-adsp-secure"), + SoC: "dragonwing", + }, + }, + { + Type: "NPU - cdsp", + Bus: "fastrpc", + PlatformInfo: &types.PlatformInfo{ + Vendor: "qualcomm", + Name: filepath.Join(tmp, "fastrpc-cdsp"), + SoC: "dragonwing", + }, + }, + { + Type: "NPU - cdsp1", + Bus: "fastrpc", + PlatformInfo: &types.PlatformInfo{ + Vendor: "qualcomm", + Name: filepath.Join(tmp, "fastrpc-cdsp1"), + SoC: "dragonwing", + }, }, - }} + } if !reflect.DeepEqual(devices, expectedDevices) { t.Fatalf("devices=%+v expected=%+v", devices, expectedDevices) } @@ -64,23 +77,39 @@ func TestDetectFromNodes(t *testing.T) { "/dev/fastrpc-cdsp", } - platforms, devices := DetectFromNodes(nodes) - if len(platforms) != 1 { - t.Fatalf("expected 1 platform, got %d", len(platforms)) - } - if platforms[0].Vendor != "qualcomm" || platforms[0].Name != "dragonwing" { - t.Fatalf("unexpected platform %+v", platforms[0]) - } + devices := DetectFromNodes(nodes) - if len(devices) != 1 { - t.Fatalf("expected 1 device, got %d", len(devices)) - } - if devices[0].Type != "npu" || devices[0].Bus != "fastrpc" { - t.Fatalf("unexpected device %+v", devices[0]) + expectedDevices := []types.DetectedDevice{ + { + Type: "NPU - adsp", + Bus: "fastrpc", + PlatformInfo: &types.PlatformInfo{ + Vendor: "qualcomm", + Name: "/dev/fastrpc-adsp", + SoC: "dragonwing", + }, + }, + { + Type: "NPU - cdsp", + Bus: "fastrpc", + PlatformInfo: &types.PlatformInfo{ + Vendor: "qualcomm", + Name: "/dev/fastrpc-cdsp", + SoC: "dragonwing", + }, + }, + { + Type: "NPU - cdsp1-secure", + Bus: "fastrpc", + PlatformInfo: &types.PlatformInfo{ + Vendor: "qualcomm", + Name: "/dev/fastrpc-cdsp1-secure", + SoC: "dragonwing", + }, + }, } - expectedNodes := []string{"/dev/fastrpc-cdsp", "/dev/fastrpc-cdsp1-secure"} - if !reflect.DeepEqual(devices[0].Nodes, expectedNodes) { - t.Fatalf("nodes=%v expected=%v", devices[0].Nodes, expectedNodes) + if !reflect.DeepEqual(devices, expectedDevices) { + t.Fatalf("devices=%+v expected=%+v", devices, expectedDevices) } } diff --git a/pkg/selector/fastrpc/fastrpc.go b/pkg/selector/fastrpc/fastrpc.go index c3823311..a75e357b 100644 --- a/pkg/selector/fastrpc/fastrpc.go +++ b/pkg/selector/fastrpc/fastrpc.go @@ -3,6 +3,7 @@ package fastrpc import ( "fmt" "path/filepath" + "strings" "testing" "github.com/canonical/go-snapctl" @@ -23,36 +24,56 @@ func Match(manifestDevice engines.Device, hostDevices []types.DetectedDevice) (i if hostDevice.Bus != "fastrpc" { continue } - if manifestDevice.Type != "" && hostDevice.Type != manifestDevice.Type { + if !deviceTypeMatch(manifestDevice.Type, hostDevice.Type) { + continue + } + if hostDevice.PlatformInfo == nil || hostDevice.PlatformInfo.Name == "" { continue } - for _, node := range hostDevice.Nodes { - matched, err := filepath.Match(nodeGlob, node) - if err != nil { - return 0, []string{fmt.Sprintf("invalid node-glob %q: %v", nodeGlob, err)} - } - if !matched { + matched, err := filepath.Match(nodeGlob, hostDevice.PlatformInfo.Name) + if err != nil { + return 0, []string{fmt.Sprintf("invalid node-glob %q: %v", nodeGlob, err)} + } + if !matched { + continue + } + + score := weights.PciDevice + weights.PciDeviceType + for _, connection := range manifestDevice.SnapConnections { + if testing.Testing() { continue } - - score := weights.PciDevice + weights.PciDeviceType - for _, connection := range manifestDevice.SnapConnections { - if testing.Testing() { - continue - } - connected, err := snapctl.IsConnected(connection).Run() - if err != nil { - return 0, []string{fmt.Sprintf("checking snap connection %q: %v", connection, err)} - } - if !connected { - return 0, []string{fmt.Sprintf("%q is not connected", connection)} - } + connected, err := snapctl.IsConnected(connection).Run() + if err != nil { + return 0, []string{fmt.Sprintf("checking snap connection %q: %v", connection, err)} + } + if !connected { + return 0, []string{fmt.Sprintf("%q is not connected", connection)} } - - return score, nil } + + return score, nil } return 0, []string{fmt.Sprintf("device node matching %q not found", nodeGlob)} } + +func deviceTypeMatch(manifestType, hostType string) bool { + if manifestType == "" { + return true + } + + manifest := strings.ToLower(strings.TrimSpace(manifestType)) + host := strings.ToLower(strings.TrimSpace(hostType)) + + if manifest == host { + return true + } + + if manifest == "npu" && strings.HasPrefix(host, "npu") { + return true + } + + return false +} diff --git a/pkg/selector/fastrpc/fastrpc_test.go b/pkg/selector/fastrpc/fastrpc_test.go index 33065305..1c94b53e 100644 --- a/pkg/selector/fastrpc/fastrpc_test.go +++ b/pkg/selector/fastrpc/fastrpc_test.go @@ -12,9 +12,19 @@ func TestMatch(t *testing.T) { { Type: "npu", Bus: "fastrpc", - Nodes: []string{ - "/dev/fastrpc-cdsp", - "/dev/fastrpc-cdsp1-secure", + PlatformInfo: &types.PlatformInfo{ + Vendor: "qualcomm", + Name: "/dev/fastrpc-cdsp", + SoC: "dragonwing", + }, + }, + { + Type: "npu", + Bus: "fastrpc", + PlatformInfo: &types.PlatformInfo{ + Vendor: "qualcomm", + Name: "/dev/fastrpc-cdsp1-secure", + SoC: "dragonwing", }, }, } diff --git a/pkg/selector/fastrpc_test.go b/pkg/selector/fastrpc_test.go index dd2132ac..e753160a 100644 --- a/pkg/selector/fastrpc_test.go +++ b/pkg/selector/fastrpc_test.go @@ -19,8 +19,10 @@ func TestFastRpcNpuSelection(t *testing.T) { { Type: "npu", Bus: "fastrpc", - Nodes: []string{ - "/dev/fastrpc-cdsp", + PlatformInfo: &types.PlatformInfo{ + Vendor: "qualcomm", + Name: "/dev/fastrpc-cdsp", + SoC: "dragonwing", }, }, }, diff --git a/pkg/types/detected_devices.go b/pkg/types/detected_devices.go index 7db5cfc5..b657e52f 100644 --- a/pkg/types/detected_devices.go +++ b/pkg/types/detected_devices.go @@ -3,10 +3,11 @@ package types type PlatformInfo struct { Vendor string `json:"vendor" yaml:"vendor"` Name string `json:"name" yaml:"name"` + SoC string `json:"soc,omitempty" yaml:"soc,omitempty"` } type DetectedDevice struct { Type string `json:"type" yaml:"type"` Bus string `json:"bus" yaml:"bus"` - Nodes []string `json:"nodes,omitempty" yaml:"nodes,omitempty"` + PlatformInfo *PlatformInfo `json:"platform_info,omitempty" yaml:"platform_info,omitempty"` } diff --git a/pkg/types/hw_info.go b/pkg/types/hw_info.go index f31b35ba..a8acc817 100644 --- a/pkg/types/hw_info.go +++ b/pkg/types/hw_info.go @@ -5,6 +5,5 @@ type HwInfo struct { Memory MemoryInfo `json:"memory,omitempty" yaml:"memory,omitempty"` Disk map[string]DirStats `json:"disk,omitempty" yaml:"disk,omitempty"` PciDevices []PciDevice `json:"pci,omitempty" yaml:"pci"` - Platforms []PlatformInfo `json:"platforms,omitempty" yaml:"platforms,omitempty"` Devices []DetectedDevice `json:"devices,omitempty" yaml:"devices,omitempty"` } From edc7d10b010524c0c4cb74db096543ab455687d4 Mon Sep 17 00:00:00 2001 From: Sinan KARAKAYA Date: Mon, 27 Apr 2026 11:14:24 +0200 Subject: [PATCH 3/6] refactor(DetectedDevice): renamed PlatformInfo->DeviceMetadata and SoC->VendorName Co-authored-by: Copilot --- pkg/hardware_info/qualcomm/qualcomm.go | 6 +++--- pkg/hardware_info/qualcomm/qualcomm_test.go | 24 ++++++++++----------- pkg/selector/fastrpc/fastrpc.go | 4 ++-- pkg/selector/fastrpc/fastrpc_test.go | 8 +++---- pkg/selector/fastrpc_test.go | 4 ++-- pkg/types/detected_devices.go | 14 ++++++------ 6 files changed, 30 insertions(+), 30 deletions(-) diff --git a/pkg/hardware_info/qualcomm/qualcomm.go b/pkg/hardware_info/qualcomm/qualcomm.go index 643d4aa7..0923b0cb 100644 --- a/pkg/hardware_info/qualcomm/qualcomm.go +++ b/pkg/hardware_info/qualcomm/qualcomm.go @@ -37,16 +37,16 @@ func DetectFromNodes(nodes []string) []types.DetectedDevice { devices = append(devices, types.DetectedDevice{ Type: detectNpuType(base), Bus: "fastrpc", - PlatformInfo: &types.PlatformInfo{ + Metadata: &types.DeviceMetadata{ Vendor: "qualcomm", Name: node, - SoC: "dragonwing", + VendorName: "dragonwing", }, }) } sort.Slice(devices, func(i, j int) bool { - return devices[i].PlatformInfo.Name < devices[j].PlatformInfo.Name + return devices[i].Metadata.Name < devices[j].Metadata.Name }) return devices diff --git a/pkg/hardware_info/qualcomm/qualcomm_test.go b/pkg/hardware_info/qualcomm/qualcomm_test.go index 820f99fa..7bdc8a9f 100644 --- a/pkg/hardware_info/qualcomm/qualcomm_test.go +++ b/pkg/hardware_info/qualcomm/qualcomm_test.go @@ -39,28 +39,28 @@ func TestInfo(t *testing.T) { { Type: "NPU - adsp-secure", Bus: "fastrpc", - PlatformInfo: &types.PlatformInfo{ + Metadata: &types.DeviceMetadata{ Vendor: "qualcomm", Name: filepath.Join(tmp, "fastrpc-adsp-secure"), - SoC: "dragonwing", + VendorName: "dragonwing", }, }, { Type: "NPU - cdsp", Bus: "fastrpc", - PlatformInfo: &types.PlatformInfo{ + Metadata: &types.DeviceMetadata{ Vendor: "qualcomm", Name: filepath.Join(tmp, "fastrpc-cdsp"), - SoC: "dragonwing", + VendorName: "dragonwing", }, }, { Type: "NPU - cdsp1", Bus: "fastrpc", - PlatformInfo: &types.PlatformInfo{ + Metadata: &types.DeviceMetadata{ Vendor: "qualcomm", Name: filepath.Join(tmp, "fastrpc-cdsp1"), - SoC: "dragonwing", + VendorName: "dragonwing", }, }, } @@ -83,28 +83,28 @@ func TestDetectFromNodes(t *testing.T) { { Type: "NPU - adsp", Bus: "fastrpc", - PlatformInfo: &types.PlatformInfo{ + Metadata: &types.DeviceMetadata{ Vendor: "qualcomm", Name: "/dev/fastrpc-adsp", - SoC: "dragonwing", + VendorName: "dragonwing", }, }, { Type: "NPU - cdsp", Bus: "fastrpc", - PlatformInfo: &types.PlatformInfo{ + Metadata: &types.DeviceMetadata{ Vendor: "qualcomm", Name: "/dev/fastrpc-cdsp", - SoC: "dragonwing", + VendorName: "dragonwing", }, }, { Type: "NPU - cdsp1-secure", Bus: "fastrpc", - PlatformInfo: &types.PlatformInfo{ + Metadata: &types.DeviceMetadata{ Vendor: "qualcomm", Name: "/dev/fastrpc-cdsp1-secure", - SoC: "dragonwing", + VendorName: "dragonwing", }, }, } diff --git a/pkg/selector/fastrpc/fastrpc.go b/pkg/selector/fastrpc/fastrpc.go index a75e357b..dafe7c0a 100644 --- a/pkg/selector/fastrpc/fastrpc.go +++ b/pkg/selector/fastrpc/fastrpc.go @@ -27,11 +27,11 @@ func Match(manifestDevice engines.Device, hostDevices []types.DetectedDevice) (i if !deviceTypeMatch(manifestDevice.Type, hostDevice.Type) { continue } - if hostDevice.PlatformInfo == nil || hostDevice.PlatformInfo.Name == "" { + if hostDevice.Metadata == nil || hostDevice.Metadata.Name == "" { continue } - matched, err := filepath.Match(nodeGlob, hostDevice.PlatformInfo.Name) + matched, err := filepath.Match(nodeGlob, hostDevice.Metadata.Name) if err != nil { return 0, []string{fmt.Sprintf("invalid node-glob %q: %v", nodeGlob, err)} } diff --git a/pkg/selector/fastrpc/fastrpc_test.go b/pkg/selector/fastrpc/fastrpc_test.go index 1c94b53e..4dd9871d 100644 --- a/pkg/selector/fastrpc/fastrpc_test.go +++ b/pkg/selector/fastrpc/fastrpc_test.go @@ -12,19 +12,19 @@ func TestMatch(t *testing.T) { { Type: "npu", Bus: "fastrpc", - PlatformInfo: &types.PlatformInfo{ + Metadata: &types.DeviceMetadata{ Vendor: "qualcomm", Name: "/dev/fastrpc-cdsp", - SoC: "dragonwing", + VendorName: "dragonwing", }, }, { Type: "npu", Bus: "fastrpc", - PlatformInfo: &types.PlatformInfo{ + Metadata: &types.DeviceMetadata{ Vendor: "qualcomm", Name: "/dev/fastrpc-cdsp1-secure", - SoC: "dragonwing", + VendorName: "dragonwing", }, }, } diff --git a/pkg/selector/fastrpc_test.go b/pkg/selector/fastrpc_test.go index e753160a..a25d113f 100644 --- a/pkg/selector/fastrpc_test.go +++ b/pkg/selector/fastrpc_test.go @@ -19,10 +19,10 @@ func TestFastRpcNpuSelection(t *testing.T) { { Type: "npu", Bus: "fastrpc", - PlatformInfo: &types.PlatformInfo{ + Metadata: &types.DeviceMetadata{ Vendor: "qualcomm", Name: "/dev/fastrpc-cdsp", - SoC: "dragonwing", + VendorName: "dragonwing", }, }, }, diff --git a/pkg/types/detected_devices.go b/pkg/types/detected_devices.go index b657e52f..96b70985 100644 --- a/pkg/types/detected_devices.go +++ b/pkg/types/detected_devices.go @@ -1,13 +1,13 @@ package types -type PlatformInfo struct { - Vendor string `json:"vendor" yaml:"vendor"` - Name string `json:"name" yaml:"name"` - SoC string `json:"soc,omitempty" yaml:"soc,omitempty"` +type DeviceMetadata struct { + Vendor string `json:"vendor" yaml:"vendor"` + Name string `json:"name" yaml:"name"` + VendorName string `json:"vendor_name,omitempty" yaml:"vendor_name,omitempty"` } type DetectedDevice struct { - Type string `json:"type" yaml:"type"` - Bus string `json:"bus" yaml:"bus"` - PlatformInfo *PlatformInfo `json:"platform_info,omitempty" yaml:"platform_info,omitempty"` + Type string `json:"type" yaml:"type"` + Bus string `json:"bus" yaml:"bus"` + Metadata *DeviceMetadata `json:"metadata,omitempty" yaml:"metadata,omitempty"` } From 659de4b8d07a1d978ab3195056ae088c8ba66220 Mon Sep 17 00:00:00 2001 From: Sinan KARAKAYA Date: Mon, 27 Apr 2026 15:39:19 +0200 Subject: [PATCH 4/6] refactor(hw-detection): correct naming and values for DetectedDevice metadata Co-authored-by: Copilot --- pkg/hardware_info/qualcomm/qualcomm.go | 7 +++-- pkg/hardware_info/qualcomm/qualcomm_test.go | 30 +++++++++------------ pkg/selector/fastrpc/fastrpc.go | 4 +-- pkg/selector/fastrpc/fastrpc_test.go | 10 +++---- pkg/selector/fastrpc_test.go | 5 ++-- pkg/types/detected_devices.go | 5 ++-- 6 files changed, 25 insertions(+), 36 deletions(-) diff --git a/pkg/hardware_info/qualcomm/qualcomm.go b/pkg/hardware_info/qualcomm/qualcomm.go index 0923b0cb..08d7bb93 100644 --- a/pkg/hardware_info/qualcomm/qualcomm.go +++ b/pkg/hardware_info/qualcomm/qualcomm.go @@ -38,15 +38,14 @@ func DetectFromNodes(nodes []string) []types.DetectedDevice { Type: detectNpuType(base), Bus: "fastrpc", Metadata: &types.DeviceMetadata{ - Vendor: "qualcomm", - Name: node, - VendorName: "dragonwing", + VendorName: "qualcomm", + ProductName: node, }, }) } sort.Slice(devices, func(i, j int) bool { - return devices[i].Metadata.Name < devices[j].Metadata.Name + return devices[i].Metadata.ProductName < devices[j].Metadata.ProductName }) return devices diff --git a/pkg/hardware_info/qualcomm/qualcomm_test.go b/pkg/hardware_info/qualcomm/qualcomm_test.go index 7bdc8a9f..d189e526 100644 --- a/pkg/hardware_info/qualcomm/qualcomm_test.go +++ b/pkg/hardware_info/qualcomm/qualcomm_test.go @@ -40,27 +40,24 @@ func TestInfo(t *testing.T) { Type: "NPU - adsp-secure", Bus: "fastrpc", Metadata: &types.DeviceMetadata{ - Vendor: "qualcomm", - Name: filepath.Join(tmp, "fastrpc-adsp-secure"), - VendorName: "dragonwing", + VendorName: "qualcomm", + ProductName: filepath.Join(tmp, "fastrpc-adsp-secure"), }, }, { Type: "NPU - cdsp", Bus: "fastrpc", Metadata: &types.DeviceMetadata{ - Vendor: "qualcomm", - Name: filepath.Join(tmp, "fastrpc-cdsp"), - VendorName: "dragonwing", + VendorName: "qualcomm", + ProductName: filepath.Join(tmp, "fastrpc-cdsp"), }, }, { Type: "NPU - cdsp1", Bus: "fastrpc", Metadata: &types.DeviceMetadata{ - Vendor: "qualcomm", - Name: filepath.Join(tmp, "fastrpc-cdsp1"), - VendorName: "dragonwing", + VendorName: "qualcomm", + ProductName: filepath.Join(tmp, "fastrpc-cdsp1"), }, }, } @@ -84,27 +81,24 @@ func TestDetectFromNodes(t *testing.T) { Type: "NPU - adsp", Bus: "fastrpc", Metadata: &types.DeviceMetadata{ - Vendor: "qualcomm", - Name: "/dev/fastrpc-adsp", - VendorName: "dragonwing", + VendorName: "qualcomm", + ProductName: "/dev/fastrpc-adsp", }, }, { Type: "NPU - cdsp", Bus: "fastrpc", Metadata: &types.DeviceMetadata{ - Vendor: "qualcomm", - Name: "/dev/fastrpc-cdsp", - VendorName: "dragonwing", + VendorName: "qualcomm", + ProductName: "/dev/fastrpc-cdsp", }, }, { Type: "NPU - cdsp1-secure", Bus: "fastrpc", Metadata: &types.DeviceMetadata{ - Vendor: "qualcomm", - Name: "/dev/fastrpc-cdsp1-secure", - VendorName: "dragonwing", + VendorName: "qualcomm", + ProductName: "/dev/fastrpc-cdsp1-secure", }, }, } diff --git a/pkg/selector/fastrpc/fastrpc.go b/pkg/selector/fastrpc/fastrpc.go index dafe7c0a..ba0111be 100644 --- a/pkg/selector/fastrpc/fastrpc.go +++ b/pkg/selector/fastrpc/fastrpc.go @@ -27,11 +27,11 @@ func Match(manifestDevice engines.Device, hostDevices []types.DetectedDevice) (i if !deviceTypeMatch(manifestDevice.Type, hostDevice.Type) { continue } - if hostDevice.Metadata == nil || hostDevice.Metadata.Name == "" { + if hostDevice.Metadata == nil || hostDevice.Metadata.ProductName == "" { continue } - matched, err := filepath.Match(nodeGlob, hostDevice.Metadata.Name) + matched, err := filepath.Match(nodeGlob, hostDevice.Metadata.ProductName) if err != nil { return 0, []string{fmt.Sprintf("invalid node-glob %q: %v", nodeGlob, err)} } diff --git a/pkg/selector/fastrpc/fastrpc_test.go b/pkg/selector/fastrpc/fastrpc_test.go index 4dd9871d..1c849e1d 100644 --- a/pkg/selector/fastrpc/fastrpc_test.go +++ b/pkg/selector/fastrpc/fastrpc_test.go @@ -13,18 +13,16 @@ func TestMatch(t *testing.T) { Type: "npu", Bus: "fastrpc", Metadata: &types.DeviceMetadata{ - Vendor: "qualcomm", - Name: "/dev/fastrpc-cdsp", - VendorName: "dragonwing", + VendorName: "qualcomm", + ProductName: "/dev/fastrpc-cdsp", }, }, { Type: "npu", Bus: "fastrpc", Metadata: &types.DeviceMetadata{ - Vendor: "qualcomm", - Name: "/dev/fastrpc-cdsp1-secure", - VendorName: "dragonwing", + VendorName: "qualcomm", + ProductName: "/dev/fastrpc-cdsp1-secure", }, }, } diff --git a/pkg/selector/fastrpc_test.go b/pkg/selector/fastrpc_test.go index a25d113f..7f5796c7 100644 --- a/pkg/selector/fastrpc_test.go +++ b/pkg/selector/fastrpc_test.go @@ -20,9 +20,8 @@ func TestFastRpcNpuSelection(t *testing.T) { Type: "npu", Bus: "fastrpc", Metadata: &types.DeviceMetadata{ - Vendor: "qualcomm", - Name: "/dev/fastrpc-cdsp", - VendorName: "dragonwing", + VendorName: "qualcomm", + ProductName: "/dev/fastrpc-cdsp", }, }, }, diff --git a/pkg/types/detected_devices.go b/pkg/types/detected_devices.go index 96b70985..6595cadc 100644 --- a/pkg/types/detected_devices.go +++ b/pkg/types/detected_devices.go @@ -1,9 +1,8 @@ package types type DeviceMetadata struct { - Vendor string `json:"vendor" yaml:"vendor"` - Name string `json:"name" yaml:"name"` - VendorName string `json:"vendor_name,omitempty" yaml:"vendor_name,omitempty"` + VendorName string `json:"vendor_name" yaml:"vendor_name"` + ProductName string `json:"product_name,omitempty" yaml:"product_name,omitempty"` } type DetectedDevice struct { From 850f228a7d5e17337c4368899caeb87f814dbc8c Mon Sep 17 00:00:00 2001 From: Sinan KARAKAYA Date: Fri, 24 Apr 2026 10:07:09 +0200 Subject: [PATCH 5/6] feat(hw-detection): added support for mediatek npu --- pkg/hardware_info/hardware-info.go | 24 ++- pkg/hardware_info/mediatek/mediatek.go | 141 ++++++++++++ pkg/hardware_info/mediatek/mediatek_test.go | 115 ++++++++++ .../testflinger/qualcomm-dragonwing-npu.yaml | 202 ++++++++++++++++++ 4 files changed, 480 insertions(+), 2 deletions(-) create mode 100644 pkg/hardware_info/mediatek/mediatek.go create mode 100644 pkg/hardware_info/mediatek/mediatek_test.go create mode 100644 test_data/testflinger/qualcomm-dragonwing-npu.yaml diff --git a/pkg/hardware_info/hardware-info.go b/pkg/hardware_info/hardware-info.go index 7db51d09..85bc8744 100644 --- a/pkg/hardware_info/hardware-info.go +++ b/pkg/hardware_info/hardware-info.go @@ -9,6 +9,7 @@ import ( "github.com/canonical/inference-snaps-cli/pkg/hardware_info/cpu" "github.com/canonical/inference-snaps-cli/pkg/hardware_info/disk" + "github.com/canonical/inference-snaps-cli/pkg/hardware_info/mediatek" "github.com/canonical/inference-snaps-cli/pkg/hardware_info/memory" "github.com/canonical/inference-snaps-cli/pkg/hardware_info/pci" "github.com/canonical/inference-snaps-cli/pkg/hardware_info/qualcomm" @@ -42,12 +43,18 @@ func Get(friendlyNames bool) (*types.HwInfo, error) { } hwInfo.PciDevices = pciDevices - devices, err := qualcomm.Info() + QCDevices, err := qualcomm.Info() if err != nil { return nil, fmt.Errorf("getting qualcomm devices: %v", err) } - hwInfo.Devices = devices + hwInfo.Devices = QCDevices + MediatekDevices, err = mediatek.Info() + if err != nil { + return nil, fmt.Errorf("getting mediatek devices: %v", err) + } + hwInfo.Devices = append(hwInfo.Devices, MediatekDevices...) + return &hwInfo, nil } @@ -119,6 +126,19 @@ func GetFromRawData(t *testing.T, device string, friendlyNames bool, testDir str t.Fatalf("error checking file '%s': %v\n", fastrpcNodesFile, err) } + mediatekCompatiblesFile := devicePath + "mediatek-compatible.txt" + if _, err := os.Stat(mediatekCompatiblesFile); err == nil { + compatiblesData, err := os.ReadFile(mediatekCompatiblesFile) + if err != nil { + t.Fatal(err) + } + + devices := mediatek.DetectFromCompatibles(strings.Fields(string(compatiblesData))) + hwInfo.Devices = append(hwInfo.Devices, devices...) + } else if !os.IsNotExist(err) { + t.Fatalf("error checking file '%s': %v\n", mediatekCompatiblesFile, err) + } + // Additional properties - we append these directly from a file, as we can not run the vendor specific tools on the machine addPropsFile := devicePath + "additional-properties.json" _, err = os.Stat(addPropsFile) diff --git a/pkg/hardware_info/mediatek/mediatek.go b/pkg/hardware_info/mediatek/mediatek.go new file mode 100644 index 00000000..a5fd905d --- /dev/null +++ b/pkg/hardware_info/mediatek/mediatek.go @@ -0,0 +1,141 @@ +package mediatek + +import ( + "fmt" + "io/fs" + "os" + "path/filepath" + "sort" + "strings" + + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +var deviceTreeRoot = "/sys/firmware/devicetree/base" + +var socToPlatform = map[string]string{ + "mt8195": "genio-1200", + "mt8188": "genio-510-700", + "mt8189": "genio-520-720", +} + +func Info() ([]types.PlatformInfo, []types.DetectedDevice, error) { + compatibleValues, err := readCompatibleValues(deviceTreeRoot) + if err != nil { + return nil, nil, fmt.Errorf("detecting mediatek apusys: %v", err) + } + + platforms, devices := DetectFromCompatibles(compatibleValues) + return platforms, devices, nil +} + +func DetectFromCompatibles(compatibleValues []string) ([]types.PlatformInfo, []types.DetectedDevice) { + platSet := make(map[string]struct{}) + matchSet := make(map[string]struct{}) + + for _, value := range compatibleValues { + soc, ok := extractAPUSoC(value) + if !ok { + continue + } + + platformName, found := socToPlatform[soc] + if !found { + platformName = "mediatek-" + soc + } + + platSet[platformName] = struct{}{} + matchSet[value] = struct{}{} + } + + if len(matchSet) == 0 { + return nil, nil + } + + platformNames := make([]string, 0, len(platSet)) + for name := range platSet { + platformNames = append(platformNames, name) + } + sort.Strings(platformNames) + + platforms := make([]types.PlatformInfo, 0, len(platformNames)) + for _, name := range platformNames { + platforms = append(platforms, types.PlatformInfo{ + Vendor: "mediatek", + Name: name, + }) + } + + matches := make([]string, 0, len(matchSet)) + for value := range matchSet { + matches = append(matches, value) + } + sort.Strings(matches) + + devices := []types.DetectedDevice{{ + Type: "npu", + Bus: "mdla", + Nodes: matches, + }} + + return platforms, devices +} + +func readCompatibleValues(root string) ([]string, error) { + var values []string + + err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if d.IsDir() || d.Name() != "compatible" { + return nil + } + + data, readErr := os.ReadFile(path) + if readErr != nil { + return readErr + } + + entries := parseCompatibleData(data) + values = append(values, entries...) + return nil + }) + if err != nil { + if os.IsNotExist(err) { + return nil, nil + } + return nil, err + } + + return values, nil +} + +func parseCompatibleData(data []byte) []string { + parts := strings.Split(string(data), "\x00") + values := make([]string, 0, len(parts)) + + for _, part := range parts { + v := strings.TrimSpace(part) + if v == "" { + continue + } + values = append(values, v) + } + + return values +} + +func extractAPUSoC(compatible string) (string, bool) { + if !strings.HasPrefix(compatible, "mediatek,") || !strings.HasSuffix(compatible, "-apusys_rv") { + return "", false + } + + body := strings.TrimPrefix(compatible, "mediatek,") + soc := strings.TrimSuffix(body, "-apusys_rv") + if soc == "" || strings.Contains(soc, ",") { + return "", false + } + + return soc, true +} diff --git a/pkg/hardware_info/mediatek/mediatek_test.go b/pkg/hardware_info/mediatek/mediatek_test.go new file mode 100644 index 00000000..afdbd568 --- /dev/null +++ b/pkg/hardware_info/mediatek/mediatek_test.go @@ -0,0 +1,115 @@ +package mediatek + +import ( + "os" + "path/filepath" + "reflect" + "testing" + + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +func TestDetectFromCompatibles(t *testing.T) { + platforms, devices := DetectFromCompatibles([]string{ + "arm,v8", + "mediatek,mt8195-apusys_rv", + "mediatek,mt8188-apusys_rv", + "mediatek,mt8189-apusys_rv", + "mediatek,mt9999-apusys_rv", + "mediatek,mt8188-apusys_rv", // duplicate should be deduped + }) + + expectedPlatforms := []types.PlatformInfo{ + {Vendor: "mediatek", Name: "genio-1200"}, + {Vendor: "mediatek", Name: "genio-510-700"}, + {Vendor: "mediatek", Name: "genio-520-720"}, + {Vendor: "mediatek", Name: "mediatek-mt9999"}, + } + if !reflect.DeepEqual(platforms, expectedPlatforms) { + t.Fatalf("platforms=%+v expected=%+v", platforms, expectedPlatforms) + } + + expectedDevices := []types.DetectedDevice{{ + Type: "npu", + Bus: "mdla", + Nodes: []string{ + "mediatek,mt8188-apusys_rv", + "mediatek,mt8189-apusys_rv", + "mediatek,mt8195-apusys_rv", + "mediatek,mt9999-apusys_rv", + }, + }} + if !reflect.DeepEqual(devices, expectedDevices) { + t.Fatalf("devices=%+v expected=%+v", devices, expectedDevices) + } +} + +func TestInfo(t *testing.T) { + tmp := t.TempDir() + originalRoot := deviceTreeRoot + deviceTreeRoot = tmp + t.Cleanup(func() { + deviceTreeRoot = originalRoot + }) + + goodDir := filepath.Join(tmp, "soc", "apu") + if err := os.MkdirAll(goodDir, 0o755); err != nil { + t.Fatal(err) + } + + // Device-tree compatible entries are NUL-separated. + if err := os.WriteFile(filepath.Join(goodDir, "compatible"), []byte("arm,v8\x00mediatek,mt8188-apusys_rv\x00"), 0o644); err != nil { + t.Fatal(err) + } + + otherDir := filepath.Join(tmp, "soc", "cpu") + if err := os.MkdirAll(otherDir, 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(otherDir, "compatible"), []byte("arm,cortex-a76\x00"), 0o644); err != nil { + t.Fatal(err) + } + + platforms, devices, err := Info() + if err != nil { + t.Fatal(err) + } + + expectedPlatforms := []types.PlatformInfo{{Vendor: "mediatek", Name: "genio-510-700"}} + if !reflect.DeepEqual(platforms, expectedPlatforms) { + t.Fatalf("platforms=%+v expected=%+v", platforms, expectedPlatforms) + } + + expectedDevices := []types.DetectedDevice{{ + Type: "npu", + Bus: "mdla", + Nodes: []string{"mediatek,mt8188-apusys_rv"}, + }} + if !reflect.DeepEqual(devices, expectedDevices) { + t.Fatalf("devices=%+v expected=%+v", devices, expectedDevices) + } +} + +func TestInfoNoMatch(t *testing.T) { + tmp := t.TempDir() + originalRoot := deviceTreeRoot + deviceTreeRoot = tmp + t.Cleanup(func() { + deviceTreeRoot = originalRoot + }) + + if err := os.MkdirAll(filepath.Join(tmp, "soc"), 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(tmp, "soc", "compatible"), []byte("arm,v8\x00"), 0o644); err != nil { + t.Fatal(err) + } + + platforms, devices, err := Info() + if err != nil { + t.Fatal(err) + } + if len(platforms) != 0 || len(devices) != 0 { + t.Fatalf("expected no mediatek npu match, got platforms=%+v devices=%+v", platforms, devices) + } +} \ No newline at end of file diff --git a/test_data/testflinger/qualcomm-dragonwing-npu.yaml b/test_data/testflinger/qualcomm-dragonwing-npu.yaml new file mode 100644 index 00000000..46eb367e --- /dev/null +++ b/test_data/testflinger/qualcomm-dragonwing-npu.yaml @@ -0,0 +1,202 @@ +job_queue: qualcomm-rb4-qcs8275-c38153 + +provision_data: + skip: true + +test_data: + test_cmds: | + set -euxo pipefail + + export DEBIAN_FRONTEND=noninteractive + sudo apt-get update + sudo apt-get install -y git jq curl ca-certificates + + WORKDIR="$HOME/inference-snaps-cli" + rm -rf "$WORKDIR" + git clone https://github.com/canonical/inference-snaps-cli.git "$WORKDIR" + cd "$WORKDIR" + + # Optional: apply your unpushed local changes as a base64-encoded git patch. + # Replace __LOCAL_PATCH_B64__ with: git diff --binary | base64 -w0 + LOCAL_PATCH_B64='diff --git a/pkg/engines/busses.go b/pkg/engines/busses.go
index 1f2b286..46f79c8 100644
--- a/pkg/engines/busses.go
+++ b/pkg/engines/busses.go
@@ -12,6 +12,8 @@ func (device Device) validateBus(extraFields []string) error {
 		return device.validatePci(extraFields)
 	case "usb":
 		return device.validateUsb(extraFields)
+	case "fastrpc":
+		return device.validateFastRpc(extraFields)
 	case "": // default to pci bus
 		return device.validatePci(extraFields)
 	default:
@@ -49,3 +51,32 @@ func (device Device) validatePci(extraFields []string) error {
 
 	return nil
 }
+
+func (device Device) validateFastRpc(extraFields []string) error {
+	if device.Type != "" && device.Type != "npu" {
+		return fmt.Errorf("fastrpc bus only supports npu devices")
+	}
+
+	validFields := []string{
+		"Type",
+		"Bus",
+		"NodeGlob",
+		"SnapConnections",
+	}
+	validFields = append(validFields, extraFields...)
+
+	t := reflect.TypeOf(device)
+	v := reflect.ValueOf(device)
+
+	for i := 0; i < t.NumField(); i++ {
+		fieldName := t.Field(i).Name
+		fieldValue := v.FieldByName(fieldName)
+		if fieldValue.IsValid() && !fieldValue.IsZero() {
+			if !slices.Contains(validFields, fieldName) {
+				return fmt.Errorf("fastrpc: invalid field: %s", fieldName)
+			}
+		}
+	}
+
+	return nil
+}
diff --git a/pkg/engines/busses_test.go b/pkg/engines/busses_test.go
index a8abd68..6155aa9 100644
--- a/pkg/engines/busses_test.go
+++ b/pkg/engines/busses_test.go
@@ -42,4 +42,13 @@ func TestDeviceBus(t *testing.T) {
 		}
 		t.Log(err)
 	})
+
+	t.Run("FastRPC bus with non-NPU type", func(t *testing.T) {
+		device.Bus = "fastrpc"
+		err := device.validate()
+		if err == nil {
+			t.Fatal("FastRPC bus should be invalid for GPU type")
+		}
+		t.Log(err)
+	})
 }
diff --git a/pkg/engines/devices_test.go b/pkg/engines/devices_test.go
index 168b356..5531036 100644
--- a/pkg/engines/devices_test.go
+++ b/pkg/engines/devices_test.go
@@ -130,6 +130,29 @@ func TestDeviceNpu(t *testing.T) {
 		}
 		t.Log(err)
 	})
+
+	t.Run("NPU fastrpc valid fields", func(t *testing.T) {
+		device = Device{Type: "npu", Bus: "fastrpc"}
+		nodeGlob := "/dev/fastrpc-cdsp*"
+		device.NodeGlob = &nodeGlob
+
+		err := device.validate()
+		if err != nil {
+			t.Fatalf("NPU fastrpc fields should be valid: %v", err)
+		}
+	})
+
+	t.Run("NPU fastrpc invalid fields", func(t *testing.T) {
+		device = Device{Type: "npu", Bus: "fastrpc"}
+		hexValue := types.HexInt(0xAA)
+		device.VendorId = &hexValue
+
+		err := device.validate()
+		if err == nil {
+			t.Fatal("NPU fastrpc fields should be invalid")
+		}
+		t.Log(err)
+	})
 }
 
 func TestDeviceTypeless(t *testing.T) {
diff --git a/pkg/engines/types.go b/pkg/engines/types.go
index 803c120..05c7da1 100644
--- a/pkg/engines/types.go
+++ b/pkg/engines/types.go
@@ -45,7 +45,7 @@ type Devices struct {
 type Device struct {
 	// General
 	Type string `yaml:"type,omitempty" json:"type,omitempty"` // cpu, gpu, npu or nil
-	Bus  string `yaml:"bus,omitempty" json:"bus,omitempty"`   // pci, usb or nil
+	Bus  string `yaml:"bus,omitempty" json:"bus,omitempty"`   // pci, usb, fastrpc or nil
 
 	// CPUs
 	Architecture *string `yaml:"architecture,omitempty" json:"architecture,omitempty"`
@@ -69,7 +69,7 @@ type Device struct {
 	ComputeCapability *string `yaml:"compute-capability,omitempty" json:"compute-capability,omitempty"`
 
 	// NPU
-	// no additional properties for now
+	NodeGlob *string `yaml:"node-glob,omitempty" json:"node-glob,omitempty"`
 
 	// Drivers
 	SnapConnections []string `yaml:"snap-connections,omitempty" json:"snap-connections,omitempty"`
diff --git a/pkg/hardware_info/disk/disk_info.go b/pkg/hardware_info/disk/disk_info.go
index 1781be2..7858efd 100644
--- a/pkg/hardware_info/disk/disk_info.go
+++ b/pkg/hardware_info/disk/disk_info.go
@@ -2,6 +2,7 @@ package disk
 
 import (
 	"fmt"
+	"os"
 
 	"github.com/canonical/inference-snaps-cli/pkg/constants"
 	"github.com/canonical/inference-snaps-cli/pkg/types"
@@ -16,6 +17,14 @@ func Info() (map[string]types.DirStats, error) {
 	var info = make(map[string]types.DirStats)
 
 	for _, dir := range directories {
+		// Skip directories that don't exist
+		if _, err := os.Stat(dir); err != nil {
+			if os.IsNotExist(err) {
+				continue
+			}
+			return nil, fmt.Errorf("checking directory %s: %v", dir, err)
+		}
+		
 		dirInfo, err := statFs(dir)
 		if err != nil {
 			return nil, fmt.Errorf("getting directory info for %s: %v", dir, err)
diff --git a/pkg/hardware_info/hardware-info.go b/pkg/hardware_info/hardware-info.go
index b6e9d27..a28b01e 100644
--- a/pkg/hardware_info/hardware-info.go
+++ b/pkg/hardware_info/hardware-info.go
@@ -4,12 +4,14 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"strings"
 	"testing"
 
 	"github.com/canonical/inference-snaps-cli/pkg/hardware_info/cpu"
 	"github.com/canonical/inference-snaps-cli/pkg/hardware_info/disk"
 	"github.com/canonical/inference-snaps-cli/pkg/hardware_info/memory"
 	"github.com/canonical/inference-snaps-cli/pkg/hardware_info/pci"
+	"github.com/canonical/inference-snaps-cli/pkg/hardware_info/qualcomm"
 	"github.com/canonical/inference-snaps-cli/pkg/types"
 )
 
@@ -40,6 +42,13 @@ func Get(friendlyNames bool) (*types.HwInfo, error) {
 	}
 	hwInfo.PciDevices = pciDevices
 
+	platforms, devices, err := qualcomm.Info()
+	if err != nil {
+		return nil, fmt.Errorf("getting qualcomm devices: %v", err)
+	}
+	hwInfo.Platforms = platforms
+	hwInfo.Devices = devices
+
 	return &hwInfo, nil
 }
 
@@ -97,6 +106,21 @@ func GetFromRawData(t *testing.T, device string, friendlyNames bool, testDir str
 	}
 	hwInfo.PciDevices = pciDevices
 
+	fastrpcNodesFile := devicePath + "fastrpc-nodes.txt"
+	if _, err := os.Stat(fastrpcNodesFile); err == nil {
+		nodesData, err := os.ReadFile(fastrpcNodesFile)
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		nodes := strings.Fields(string(nodesData))
+		platforms, devices := qualcomm.DetectFromNodes(nodes)
+		hwInfo.Platforms = platforms
+		hwInfo.Devices = devices
+	} else if !os.IsNotExist(err) {
+		t.Fatalf("error checking file '%s': %v\n", fastrpcNodesFile, err)
+	}
+
 	// Additional properties - we append these directly from a file, as we can not run the vendor specific tools on the machine
 	addPropsFile := devicePath + "additional-properties.json"
 	_, err = os.Stat(addPropsFile)
diff --git a/pkg/hardware_info/qualcomm/qualcomm.go b/pkg/hardware_info/qualcomm/qualcomm.go
new file mode 100644
index 0000000..27ca274
--- /dev/null
+++ b/pkg/hardware_info/qualcomm/qualcomm.go
@@ -0,0 +1,94 @@
+package qualcomm
+
+import (
+	"fmt"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/canonical/inference-snaps-cli/pkg/types"
+)
+
+var devRoot = "/dev"
+
+func Info() ([]types.PlatformInfo, []types.DetectedDevice, error) {
+	fastrpcNodes, err := globSorted(filepath.Join(devRoot, "fastrpc-*"))
+	if err != nil {
+		return nil, nil, fmt.Errorf("detecting fastrpc nodes: %v", err)
+	}
+
+	cdspNodes, err := globSorted(filepath.Join(devRoot, "fastrpc-cdsp*"))
+	if err != nil {
+		return nil, nil, fmt.Errorf("detecting cdsp fastrpc nodes: %v", err)
+	}
+
+	var platforms []types.PlatformInfo
+	if len(fastrpcNodes) > 0 {
+		platforms = append(platforms, types.PlatformInfo{
+			Vendor: "qualcomm",
+			Name:   "dragonwing",
+		})
+	}
+
+	var devices []types.DetectedDevice
+	if len(cdspNodes) > 0 {
+		devices = append(devices, types.DetectedDevice{
+			Type:  "npu",
+			Bus:   "fastrpc",
+			Nodes: cdspNodes,
+		})
+	}
+
+	return platforms, devices, nil
+}
+
+func DetectFromNodes(nodes []string) ([]types.PlatformInfo, []types.DetectedDevice) {
+	var fastrpcNodes []string
+	var cdspNodes []string
+
+	for _, node := range nodes {
+		node = strings.TrimSpace(node)
+		if node == "" {
+			continue
+		}
+
+		base := filepath.Base(node)
+		if strings.HasPrefix(base, "fastrpc-") {
+			fastrpcNodes = append(fastrpcNodes, node)
+		}
+		if strings.HasPrefix(base, "fastrpc-cdsp") {
+			cdspNodes = append(cdspNodes, node)
+		}
+	}
+
+	sort.Strings(fastrpcNodes)
+	sort.Strings(cdspNodes)
+
+	var platforms []types.PlatformInfo
+	if len(fastrpcNodes) > 0 {
+		platforms = append(platforms, types.PlatformInfo{
+			Vendor: "qualcomm",
+			Name:   "dragonwing",
+		})
+	}
+
+	var devices []types.DetectedDevice
+	if len(cdspNodes) > 0 {
+		devices = append(devices, types.DetectedDevice{
+			Type:  "npu",
+			Bus:   "fastrpc",
+			Nodes: cdspNodes,
+		})
+	}
+
+	return platforms, devices
+}
+
+func globSorted(pattern string) ([]string, error) {
+	matches, err := filepath.Glob(pattern)
+	if err != nil {
+		return nil, err
+	}
+	sort.Strings(matches)
+	return matches, nil
+}
diff --git a/pkg/hardware_info/qualcomm/qualcomm_test.go b/pkg/hardware_info/qualcomm/qualcomm_test.go
new file mode 100644
index 0000000..cf7914c
--- /dev/null
+++ b/pkg/hardware_info/qualcomm/qualcomm_test.go
@@ -0,0 +1,86 @@
+package qualcomm
+
+import (
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/canonical/inference-snaps-cli/pkg/types"
+)
+
+func TestInfo(t *testing.T) {
+	tmp := t.TempDir()
+	originalRoot := devRoot
+	devRoot = tmp
+	t.Cleanup(func() {
+		devRoot = originalRoot
+	})
+
+	_, err := os.Create(filepath.Join(tmp, "fastrpc-adsp-secure"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = os.Create(filepath.Join(tmp, "fastrpc-cdsp"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = os.Create(filepath.Join(tmp, "fastrpc-cdsp1"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	platforms, devices, err := Info()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	expectedPlatforms := []types.PlatformInfo{{
+		Vendor: "qualcomm",
+		Name:   "dragonwing",
+	}}
+	if !reflect.DeepEqual(platforms, expectedPlatforms) {
+		t.Fatalf("platforms=%+v expected=%+v", platforms, expectedPlatforms)
+	}
+
+	expectedDevices := []types.DetectedDevice{{
+		Type: "npu",
+		Bus:  "fastrpc",
+		Nodes: []string{
+			filepath.Join(tmp, "fastrpc-cdsp"),
+			filepath.Join(tmp, "fastrpc-cdsp1"),
+		},
+	}}
+	if !reflect.DeepEqual(devices, expectedDevices) {
+		t.Fatalf("devices=%+v expected=%+v", devices, expectedDevices)
+	}
+}
+
+func TestDetectFromNodes(t *testing.T) {
+	nodes := []string{
+		"/dev/fastrpc-cdsp1-secure",
+		"/dev/fastrpc-adsp",
+		"/dev/something-else",
+		"/dev/fastrpc-cdsp",
+	}
+
+	platforms, devices := DetectFromNodes(nodes)
+	if len(platforms) != 1 {
+		t.Fatalf("expected 1 platform, got %d", len(platforms))
+	}
+	if platforms[0].Vendor != "qualcomm" || platforms[0].Name != "dragonwing" {
+		t.Fatalf("unexpected platform %+v", platforms[0])
+	}
+
+	if len(devices) != 1 {
+		t.Fatalf("expected 1 device, got %d", len(devices))
+	}
+	if devices[0].Type != "npu" || devices[0].Bus != "fastrpc" {
+		t.Fatalf("unexpected device %+v", devices[0])
+	}
+
+	expectedNodes := []string{"/dev/fastrpc-cdsp", "/dev/fastrpc-cdsp1-secure"}
+	if !reflect.DeepEqual(devices[0].Nodes, expectedNodes) {
+		t.Fatalf("nodes=%v expected=%v", devices[0].Nodes, expectedNodes)
+	}
+}
diff --git a/pkg/selector/fastrpc/fastrpc.go b/pkg/selector/fastrpc/fastrpc.go
new file mode 100644
index 0000000..c382331
--- /dev/null
+++ b/pkg/selector/fastrpc/fastrpc.go
@@ -0,0 +1,58 @@
+package fastrpc
+
+import (
+	"fmt"
+	"path/filepath"
+	"testing"
+
+	"github.com/canonical/go-snapctl"
+	"github.com/canonical/inference-snaps-cli/pkg/engines"
+	"github.com/canonical/inference-snaps-cli/pkg/selector/weights"
+	"github.com/canonical/inference-snaps-cli/pkg/types"
+)
+
+const defaultNpuNodeGlob = "/dev/fastrpc-cdsp*"
+
+func Match(manifestDevice engines.Device, hostDevices []types.DetectedDevice) (int, []string) {
+	nodeGlob := defaultNpuNodeGlob
+	if manifestDevice.NodeGlob != nil {
+		nodeGlob = *manifestDevice.NodeGlob
+	}
+
+	for _, hostDevice := range hostDevices {
+		if hostDevice.Bus != "fastrpc" {
+			continue
+		}
+		if manifestDevice.Type != "" && hostDevice.Type != manifestDevice.Type {
+			continue
+		}
+
+		for _, node := range hostDevice.Nodes {
+			matched, err := filepath.Match(nodeGlob, node)
+			if err != nil {
+				return 0, []string{fmt.Sprintf("invalid node-glob %q: %v", nodeGlob, err)}
+			}
+			if !matched {
+				continue
+			}
+
+			score := weights.PciDevice + weights.PciDeviceType
+			for _, connection := range manifestDevice.SnapConnections {
+				if testing.Testing() {
+					continue
+				}
+				connected, err := snapctl.IsConnected(connection).Run()
+				if err != nil {
+					return 0, []string{fmt.Sprintf("checking snap connection %q: %v", connection, err)}
+				}
+				if !connected {
+					return 0, []string{fmt.Sprintf("%q is not connected", connection)}
+				}
+			}
+
+			return score, nil
+		}
+	}
+
+	return 0, []string{fmt.Sprintf("device node matching %q not found", nodeGlob)}
+}
diff --git a/pkg/selector/fastrpc/fastrpc_test.go b/pkg/selector/fastrpc/fastrpc_test.go
new file mode 100644
index 0000000..3306530
--- /dev/null
+++ b/pkg/selector/fastrpc/fastrpc_test.go
@@ -0,0 +1,50 @@
+package fastrpc
+
+import (
+	"testing"
+
+	"github.com/canonical/inference-snaps-cli/pkg/engines"
+	"github.com/canonical/inference-snaps-cli/pkg/types"
+)
+
+func TestMatch(t *testing.T) {
+	hostDevices := []types.DetectedDevice{
+		{
+			Type: "npu",
+			Bus:  "fastrpc",
+			Nodes: []string{
+				"/dev/fastrpc-cdsp",
+				"/dev/fastrpc-cdsp1-secure",
+			},
+		},
+	}
+
+	t.Run("default pattern", func(t *testing.T) {
+		device := engines.Device{Type: "npu", Bus: "fastrpc"}
+		score, issues := Match(device, hostDevices)
+		if score == 0 || len(issues) > 0 {
+			t.Fatalf("expected a positive score with no issues, score=%d issues=%v", score, issues)
+		}
+	})
+
+	t.Run("custom node glob", func(t *testing.T) {
+		nodeGlob := "/dev/fastrpc-cdsp1*"
+		device := engines.Device{Type: "npu", Bus: "fastrpc", NodeGlob: &nodeGlob}
+		score, issues := Match(device, hostDevices)
+		if score == 0 || len(issues) > 0 {
+			t.Fatalf("expected a positive score with no issues, score=%d issues=%v", score, issues)
+		}
+	})
+
+	t.Run("no matching node", func(t *testing.T) {
+		nodeGlob := "/dev/fastrpc-gdsp*"
+		device := engines.Device{Type: "npu", Bus: "fastrpc", NodeGlob: &nodeGlob}
+		score, issues := Match(device, hostDevices)
+		if score != 0 {
+			t.Fatalf("expected score=0, got %d", score)
+		}
+		if len(issues) == 0 {
+			t.Fatal("expected compatibility issues")
+		}
+	})
+}
diff --git a/pkg/selector/fastrpc_test.go b/pkg/selector/fastrpc_test.go
new file mode 100644
index 0000000..dd2132a
--- /dev/null
+++ b/pkg/selector/fastrpc_test.go
@@ -0,0 +1,52 @@
+package selector
+
+import (
+	"testing"
+
+	"github.com/canonical/inference-snaps-cli/pkg/engines"
+	"github.com/canonical/inference-snaps-cli/pkg/types"
+)
+
+func TestFastRpcNpuSelection(t *testing.T) {
+	hwInfo := &types.HwInfo{
+		Memory: types.MemoryInfo{TotalRam: 8 * 1024 * 1024 * 1024},
+		Disk: map[string]types.DirStats{
+			"/var/lib/snapd/snaps": {
+				Avail: 20 * 1024 * 1024 * 1024,
+			},
+		},
+		Devices: []types.DetectedDevice{
+			{
+				Type: "npu",
+				Bus:  "fastrpc",
+				Nodes: []string{
+					"/dev/fastrpc-cdsp",
+				},
+			},
+		},
+	}
+
+	manifest := engines.Manifest{
+		Name:        "qualcomm-npu",
+		Description: "qualcomm dragonwing npu",
+		Vendor:      "qualcomm",
+		Grade:       "stable",
+		Devices: engines.Devices{
+			Anyof: []engines.Device{{
+				Type: "npu",
+				Bus:  "fastrpc",
+			}},
+		},
+	}
+
+	score, report, err := checkEngine(hwInfo, manifest)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !report.EngineCompatible() {
+		t.Fatalf("expected engine to be compatible: %+v", report)
+	}
+	if score <= 0 {
+		t.Fatalf("expected positive score, got %d", score)
+	}
+}
diff --git a/pkg/selector/select_stack.go b/pkg/selector/select_stack.go
index 671f52c..bd84a5d 100644
--- a/pkg/selector/select_stack.go
+++ b/pkg/selector/select_stack.go
@@ -8,6 +8,7 @@ import (
 	"github.com/canonical/inference-snaps-cli/pkg/constants"
 	"github.com/canonical/inference-snaps-cli/pkg/engines"
 	"github.com/canonical/inference-snaps-cli/pkg/selector/cpu"
+	"github.com/canonical/inference-snaps-cli/pkg/selector/fastrpc"
 	"github.com/canonical/inference-snaps-cli/pkg/selector/pci"
 	"github.com/canonical/inference-snaps-cli/pkg/types"
 	"github.com/canonical/inference-snaps-cli/pkg/utils"
@@ -165,6 +166,15 @@ func scoreDevicesAll(hardwareInfo *types.HwInfo, devices []engines.Device) int {
 			compatible = false
 			devices[i].CompatibilityIssues = append(devices[i].CompatibilityIssues, "usb device matching not implemented")
 
+		} else if devices[i].Bus == "fastrpc" {
+			fastRpcScore, fastRpcIssues := fastrpc.Match(devices[i], hardwareInfo.Devices)
+			if len(fastRpcIssues) > 0 {
+				compatible = false
+				devices[i].CompatibilityIssues = append(devices[i].CompatibilityIssues, fastRpcIssues...)
+			} else {
+				compatibilityScore += fastRpcScore
+			}
+
 		} else if devices[i].Bus == "" || devices[i].Bus == "pci" {
 			// Fallback to PCI as default bus
 			pciScore, pciIssues := pci.Match(devices[i], hardwareInfo.PciDevices)
@@ -204,6 +214,15 @@ func scoreDevicesAny(hardwareInfo *types.HwInfo, devices []engines.Device) int {
 			compatible = false
 			device.CompatibilityIssues = append(device.CompatibilityIssues, "usb device matching not implemented")
 
+		} else if device.Bus == "fastrpc" {
+			fastRpcScore, fastRpcIssues := fastrpc.Match(device, hardwareInfo.Devices)
+			if len(fastRpcIssues) > 0 {
+				devices[i].CompatibilityIssues = append(device.CompatibilityIssues, fastRpcIssues...)
+			} else {
+				devicesFound++
+				compatibilityScore += fastRpcScore
+			}
+
 		} else if device.Bus == "" || device.Bus == "pci" {
 			// Fallback to PCI as default bus
 			pciScore, pciIssues := pci.Match(device, hardwareInfo.PciDevices)
diff --git a/pkg/types/detected_devices.go b/pkg/types/detected_devices.go
new file mode 100644
index 0000000..7db5cfc
--- /dev/null
+++ b/pkg/types/detected_devices.go
@@ -0,0 +1,12 @@
+package types
+
+type PlatformInfo struct {
+	Vendor string `json:"vendor" yaml:"vendor"`
+	Name   string `json:"name" yaml:"name"`
+}
+
+type DetectedDevice struct {
+	Type  string   `json:"type" yaml:"type"`
+	Bus   string   `json:"bus" yaml:"bus"`
+	Nodes []string `json:"nodes,omitempty" yaml:"nodes,omitempty"`
+}
diff --git a/pkg/types/hw_info.go b/pkg/types/hw_info.go
index 9548c73..f31b35b 100644
--- a/pkg/types/hw_info.go
+++ b/pkg/types/hw_info.go
@@ -5,4 +5,6 @@ type HwInfo struct {
 	Memory     MemoryInfo          `json:"memory,omitempty" yaml:"memory,omitempty"`
 	Disk       map[string]DirStats `json:"disk,omitempty" yaml:"disk,omitempty"`
 	PciDevices []PciDevice         `json:"pci,omitempty" yaml:"pci"`
+	Platforms  []PlatformInfo      `json:"platforms,omitempty" yaml:"platforms,omitempty"`
+	Devices    []DetectedDevice    `json:"devices,omitempty" yaml:"devices,omitempty"`
 }
diff --git a/test_data/testflinger/qualcomm-dragonwing-npu.yaml b/test_data/testflinger/qualcomm-dragonwing-npu.yaml
new file mode 100644
index 0000000..b575faa
--- /dev/null
+++ b/test_data/testflinger/qualcomm-dragonwing-npu.yaml
@@ -0,0 +1,202 @@
+job_queue: dragonwing-evaluation-kit-iq-9075-evk
+
+provision_data:
+  skip: true
+
+test_data:
+  test_cmds: |
+    set -euxo pipefail
+
+    export DEBIAN_FRONTEND=noninteractive
+    sudo apt-get update
+    sudo apt-get install -y git jq curl ca-certificates
+
+    WORKDIR="$HOME/inference-snaps-cli"
+    rm -rf "$WORKDIR"
+    git clone https://github.com/canonical/inference-snaps-cli.git "$WORKDIR"
+    cd "$WORKDIR"
+
+    # Optional: apply your unpushed local changes as a base64-encoded git patch.
+    # Replace __LOCAL_PATCH_B64__ with: git diff --binary | base64 -w0
+    LOCAL_PATCH_B64='__LOCAL_PATCH_B64__'
+
+    if [ -n "$LOCAL_PATCH_B64" ] && [ "$LOCAL_PATCH_B64" != '__LOCAL_PATCH_B64__' ]; then
+      printf '%s' "$LOCAL_PATCH_B64" | base64 -d > /tmp/local.patch
+
+      # Ensure parent directories for new/renamed files exist before apply --check.
+      awk '/^\+\+\+ b\// { print substr($2, 3) }' /tmp/local.patch \
+        | grep -v '^/dev/null$' \
+        | xargs -r -n1 dirname \
+        | sort -u \
+        | xargs -r mkdir -p
+
+      git apply --check /tmp/local.patch
+      git apply /tmp/local.patch
+    else
+      echo "No local patch embedded; running against repository HEAD"
+    fi
+
+    # Try to use existing Go first (so tests can work even with older versions)
+    if command -v go &> /dev/null; then
+      echo "Go already installed: $(go version)"
+      export PATH="$(go env GOROOT)/bin:$PATH"
+    else
+      echo "Go not found, attempting to install..."
+      GO_VERSION_RAW="$(awk '/^go /{print $2; exit}' go.mod)"
+      case "$GO_VERSION_RAW" in
+        *.*.*) GO_VERSION="$GO_VERSION_RAW" ;;
+        *.*) GO_VERSION="${GO_VERSION_RAW}.0" ;;
+        *) echo "Unsupported go.mod version format: $GO_VERSION_RAW"; exit 1 ;;
+      esac
+
+      case "$(uname -m)" in
+        x86_64) GO_ARCH="amd64" ;;
+        aarch64|arm64) GO_ARCH="arm64" ;;
+        *) echo "Unsupported architecture: $(uname -m)"; exit 1 ;;
+      esac
+
+      GO_TARBALL="go${GO_VERSION}.linux-${GO_ARCH}.tar.gz"
+      
+      # Try multiple download URLs with fallback strategy
+      declare -a URLS=(
+        "https://go.dev/dl/${GO_TARBALL}"
+        "https://golang.google.cn/dl/${GO_TARBALL}"
+        "https://mirror.ghproxy.com/https://github.com/golang/go/releases/download/go${GO_VERSION}/${GO_TARBALL}"
+      )
+      
+      DOWNLOADED=0
+      for URL in "${URLS[@]}"; do
+        echo "Attempting to download from: $URL"
+        if curl --connect-timeout 5 --max-time 60 -fsSLo "/tmp/${GO_TARBALL}" "$URL"; then
+          echo "Successfully downloaded Go from $URL"
+          DOWNLOADED=1
+          break
+        fi
+        echo "Failed to download from $URL, trying next..."
+      done
+      
+      if [ $DOWNLOADED -eq 0 ]; then
+        echo "WARNING: Could not download Go $GO_VERSION. Attempting to use system Go..."
+        if sudo apt-get install -y golang-go; then
+          echo "Installed system Go via apt"
+          export PATH="$(go env GOROOT)/bin:$PATH"
+        else
+          echo "ERROR: Could not install Go by any method"
+          exit 1
+        fi
+      else
+        sudo rm -rf /usr/local/go
+        sudo tar -C /usr/local -xzf "/tmp/${GO_TARBALL}"
+        export PATH="/usr/local/go/bin:$PATH"
+      fi
+    fi
+
+    go version
+
+    go build -o inference-snaps-cli ./cmd/cli
+
+    # Strict diagnostic: verify this job is really executing on the expected DUT.
+    echo "=== SYSTEM DIAGNOSTICS ==="
+    echo "Host: $(hostname)"
+    echo "Kernel: $(uname -r)"
+    echo "Arch: $(uname -m)"
+    [ -f /etc/os-release ] && cat /etc/os-release
+    if [ -f /sys/firmware/devicetree/base/model ]; then
+      echo "Device-tree model:"
+      tr -d '\000' < /sys/firmware/devicetree/base/model || true
+    fi
+    if [ -f /proc/device-tree/model ]; then
+      echo "Proc device-tree model:"
+      tr -d '\000' < /proc/device-tree/model || true
+    fi
+    echo "=========================="
+    echo ""
+
+    # Hard fail if this is not an ARM DUT. Earlier failures showed x86_64/kvm runs.
+    case "$(uname -m)" in
+      aarch64|arm64) ;;
+      *)
+        echo "ERROR: Job is not running on an ARM Qualcomm DUT (arch=$(uname -m))."
+        echo "ERROR: This indicates wrong queue allocation or wrong execution environment."
+        exit 2
+        ;;
+    esac
+
+    # 1) Wait for real FastRPC nodes to appear (no mock nodes).
+    echo "Waiting for /dev/fastrpc-* nodes (up to 90s)..."
+    FASTRPC_FOUND=0
+    for _ in $(seq 1 30); do
+      if ls -1 /dev/fastrpc-* >/dev/null 2>&1; then
+        FASTRPC_FOUND=1
+        break
+      fi
+      sleep 3
+    done
+
+    if [ "$FASTRPC_FOUND" -ne 1 ]; then
+      echo "ERROR: No /dev/fastrpc-* nodes found after waiting."
+      echo "Listing /dev entries that might be relevant:"
+      ls -1 /dev | grep -Ei 'fastrpc|cdsp|adsp|qcom|dsp' || true
+      echo "Loaded modules mentioning fastrpc:"
+      if command -v lsmod >/dev/null 2>&1; then
+        lsmod | grep -i fastrpc || true
+      else
+        grep -i fastrpc /proc/modules || true
+      fi
+      exit 3
+    fi
+
+    echo "FastRPC nodes found:"
+    ls -1 /dev/fastrpc-*
+    ls -1 /dev/fastrpc-cdsp* || true
+
+    # 2) Verify machine info contains Qualcomm Dragonwing and NPU/FastRPC entries.
+    echo ""
+    echo "=== MACHINE INFO TEST ==="
+    # Some DUT images do not include snapd preinstalled; ensure expected path exists.
+    sudo mkdir -p /var/lib/snapd/snaps
+    ./inference-snaps-cli show-machine --format=json > /tmp/hardware-info.json
+    echo "Machine info (first 80 lines):"
+    head -80 /tmp/hardware-info.json
+
+    # Strict assertions: on a real DUT with FastRPC nodes, these must be present.
+    jq -e '.platforms | map(select(.vendor == "qualcomm" and .name == "dragonwing")) | length > 0' /tmp/hardware-info.json
+    jq -e '.devices | map(select(.type == "npu" and .bus == "fastrpc")) | length > 0' /tmp/hardware-info.json
+    jq -e '.devices[] | select(.type == "npu" and .bus == "fastrpc") | .nodes | length > 0' /tmp/hardware-info.json
+    echo "Machine detection checks passed."
+
+    # 3) Verify selector can match an NPU engine using the new fastrpc bus.
+    echo ""
+    echo "=== SELECTOR MATCHING TEST ==="
+    mkdir -p /tmp/engines/qualcomm-npu-smoke
+    cat > /tmp/engines/qualcomm-npu-smoke/engine.yaml << 'ENGINE_EOF'
+    name: qualcomm-npu-smoke
+    description: Smoke test engine for Qualcomm Dragonwing NPU detection
+    vendor: Canonical
+    grade: stable
+    devices:
+      anyof:
+        - type: npu
+          bus: fastrpc
+    ENGINE_EOF
+
+    echo "Running selector with NPU engine..."
+    ./inference-snaps-cli show-machine --format=json | ./inference-snaps-cli debug select-engine --engines /tmp/engines > /tmp/select-engine.out 2>&1
+    echo "Selector output:"
+    cat /tmp/select-engine.out
+    
+    grep -q "qualcomm-npu-smoke" /tmp/select-engine.out
+    echo "Selector matched NPU engine."
+
+    echo ""
+    echo "=== TEST SUMMARY ==="
+    echo "Go toolchain configured"
+    echo "inference-snaps-cli built successfully"
+    echo "Machine detection validated on real FastRPC nodes"
+    echo "Selector matching validated"
+    echo ""
+    echo "Qualcomm Dragonwing NPU detection implementation validated."
+reserve_data:
+  ssh_keys:
+    - "lp:sinan-k"
+  timeout: 5h
\ No newline at end of file
' + + if [ -n "$LOCAL_PATCH_B64" ] && [ "$LOCAL_PATCH_B64" != '__LOCAL_PATCH_B64__' ]; then + printf '%s' "$LOCAL_PATCH_B64" | base64 -d > /tmp/local.patch + + # Ensure parent directories for new/renamed files exist before apply --check. + awk '/^\+\+\+ b\// { print substr($2, 3) }' /tmp/local.patch \ + | grep -v '^/dev/null$' \ + | xargs -r -n1 dirname \ + | sort -u \ + | xargs -r mkdir -p + + git apply --check /tmp/local.patch + git apply /tmp/local.patch + else + echo "No local patch embedded; running against repository HEAD" + fi + + # Try to use existing Go first (so tests can work even with older versions) + if command -v go &> /dev/null; then + echo "Go already installed: $(go version)" + export PATH="$(go env GOROOT)/bin:$PATH" + else + echo "Go not found, attempting to install..." + GO_VERSION_RAW="$(awk '/^go /{print $2; exit}' go.mod)" + case "$GO_VERSION_RAW" in + *.*.*) GO_VERSION="$GO_VERSION_RAW" ;; + *.*) GO_VERSION="${GO_VERSION_RAW}.0" ;; + *) echo "Unsupported go.mod version format: $GO_VERSION_RAW"; exit 1 ;; + esac + + case "$(uname -m)" in + x86_64) GO_ARCH="amd64" ;; + aarch64|arm64) GO_ARCH="arm64" ;; + *) echo "Unsupported architecture: $(uname -m)"; exit 1 ;; + esac + + GO_TARBALL="go${GO_VERSION}.linux-${GO_ARCH}.tar.gz" + + # Try multiple download URLs with fallback strategy + declare -a URLS=( + "https://go.dev/dl/${GO_TARBALL}" + "https://golang.google.cn/dl/${GO_TARBALL}" + "https://mirror.ghproxy.com/https://github.com/golang/go/releases/download/go${GO_VERSION}/${GO_TARBALL}" + ) + + DOWNLOADED=0 + for URL in "${URLS[@]}"; do + echo "Attempting to download from: $URL" + if curl --connect-timeout 5 --max-time 60 -fsSLo "/tmp/${GO_TARBALL}" "$URL"; then + echo "Successfully downloaded Go from $URL" + DOWNLOADED=1 + break + fi + echo "Failed to download from $URL, trying next..." + done + + if [ $DOWNLOADED -eq 0 ]; then + echo "WARNING: Could not download Go $GO_VERSION. Attempting to use system Go..." + if sudo apt-get install -y golang-go; then + echo "Installed system Go via apt" + export PATH="$(go env GOROOT)/bin:$PATH" + else + echo "ERROR: Could not install Go by any method" + exit 1 + fi + else + sudo rm -rf /usr/local/go + sudo tar -C /usr/local -xzf "/tmp/${GO_TARBALL}" + export PATH="/usr/local/go/bin:$PATH" + fi + fi + + go version + + go build -o inference-snaps-cli ./cmd/cli + + # Strict diagnostic: verify this job is really executing on the expected DUT. + echo "=== SYSTEM DIAGNOSTICS ===" + echo "Host: $(hostname)" + echo "Kernel: $(uname -r)" + echo "Arch: $(uname -m)" + [ -f /etc/os-release ] && cat /etc/os-release + if [ -f /sys/firmware/devicetree/base/model ]; then + echo "Device-tree model:" + tr -d '\000' < /sys/firmware/devicetree/base/model || true + fi + if [ -f /proc/device-tree/model ]; then + echo "Proc device-tree model:" + tr -d '\000' < /proc/device-tree/model || true + fi + echo "==========================" + echo "" + + # Hard fail if this is not an ARM DUT. Earlier failures showed x86_64/kvm runs. + case "$(uname -m)" in + aarch64|arm64) ;; + *) + echo "ERROR: Job is not running on an ARM Qualcomm DUT (arch=$(uname -m))." + echo "ERROR: This indicates wrong queue allocation or wrong execution environment." + exit 2 + ;; + esac + + # 1) Wait for real FastRPC nodes to appear (no mock nodes). + echo "Waiting for /dev/fastrpc-* nodes (up to 90s)..." + FASTRPC_FOUND=0 + for _ in $(seq 1 30); do + if ls -1 /dev/fastrpc-* >/dev/null 2>&1; then + FASTRPC_FOUND=1 + break + fi + sleep 3 + done + + if [ "$FASTRPC_FOUND" -ne 1 ]; then + echo "ERROR: No /dev/fastrpc-* nodes found after waiting." + echo "Listing /dev entries that might be relevant:" + ls -1 /dev | grep -Ei 'fastrpc|cdsp|adsp|qcom|dsp' || true + echo "Loaded modules mentioning fastrpc:" + if command -v lsmod >/dev/null 2>&1; then + lsmod | grep -i fastrpc || true + else + grep -i fastrpc /proc/modules || true + fi + exit 3 + fi + + echo "FastRPC nodes found:" + ls -1 /dev/fastrpc-* + ls -1 /dev/fastrpc-cdsp* || true + + # 2) Verify machine info contains Qualcomm Dragonwing and NPU/FastRPC entries. + echo "" + echo "=== MACHINE INFO TEST ===" + # Some DUT images do not include snapd preinstalled; ensure expected path exists. + sudo mkdir -p /var/lib/snapd/snaps + ./inference-snaps-cli show-machine --format=json > /tmp/hardware-info.json + echo "Machine info (first 80 lines):" + head -80 /tmp/hardware-info.json + + # Strict assertions: on a real DUT with FastRPC nodes, these must be present. + jq -e '.platforms | map(select(.vendor == "qualcomm" and .name == "dragonwing")) | length > 0' /tmp/hardware-info.json + jq -e '.devices | map(select(.type == "npu" and .bus == "fastrpc")) | length > 0' /tmp/hardware-info.json + jq -e '.devices[] | select(.type == "npu" and .bus == "fastrpc") | .nodes | length > 0' /tmp/hardware-info.json + echo "Machine detection checks passed." + + # 3) Verify selector can match an NPU engine using the new fastrpc bus. + echo "" + echo "=== SELECTOR MATCHING TEST ===" + mkdir -p /tmp/engines/qualcomm-npu-smoke + cat > /tmp/engines/qualcomm-npu-smoke/engine.yaml << 'ENGINE_EOF' + name: qualcomm-npu-smoke + description: Smoke test engine for Qualcomm Dragonwing NPU detection + vendor: Canonical + grade: stable + devices: + anyof: + - type: npu + bus: fastrpc + ENGINE_EOF + + echo "Running selector with NPU engine..." + ./inference-snaps-cli show-machine --format=json | ./inference-snaps-cli debug select-engine --engines /tmp/engines > /tmp/select-engine.out 2>&1 + echo "Selector output:" + cat /tmp/select-engine.out + + grep -q "qualcomm-npu-smoke" /tmp/select-engine.out + echo "Selector matched NPU engine." + + echo "" + echo "=== TEST SUMMARY ===" + echo "Go toolchain configured" + echo "inference-snaps-cli built successfully" + echo "Machine detection validated on real FastRPC nodes" + echo "Selector matching validated" + echo "" + echo "Qualcomm Dragonwing NPU detection implementation validated." +reserve_data: + ssh_keys: + - "lp:sinan-k" + timeout: 5h \ No newline at end of file From 47530d01cc1b4b8cd9f5f76ac8631f7fc3c74611 Mon Sep 17 00:00:00 2001 From: Sinan KARAKAYA Date: Mon, 27 Apr 2026 16:35:01 +0200 Subject: [PATCH 6/6] refactor(mediatek): updated DetectedDevice struct based on QC refactor Co-authored-by: Copilot --- pkg/hardware_info/hardware-info.go | 10 ++-- pkg/hardware_info/mediatek/mediatek.go | 42 +++++-------- pkg/hardware_info/mediatek/mediatek_test.go | 65 ++++++++++++--------- 3 files changed, 57 insertions(+), 60 deletions(-) diff --git a/pkg/hardware_info/hardware-info.go b/pkg/hardware_info/hardware-info.go index 85bc8744..b1e991b3 100644 --- a/pkg/hardware_info/hardware-info.go +++ b/pkg/hardware_info/hardware-info.go @@ -43,18 +43,18 @@ func Get(friendlyNames bool) (*types.HwInfo, error) { } hwInfo.PciDevices = pciDevices - QCDevices, err := qualcomm.Info() + qcDevices, err := qualcomm.Info() if err != nil { return nil, fmt.Errorf("getting qualcomm devices: %v", err) } - hwInfo.Devices = QCDevices + hwInfo.Devices = qcDevices - MediatekDevices, err = mediatek.Info() + mediatekDevices, err := mediatek.Info() if err != nil { return nil, fmt.Errorf("getting mediatek devices: %v", err) } - hwInfo.Devices = append(hwInfo.Devices, MediatekDevices...) - + hwInfo.Devices = append(hwInfo.Devices, mediatekDevices...) + return &hwInfo, nil } diff --git a/pkg/hardware_info/mediatek/mediatek.go b/pkg/hardware_info/mediatek/mediatek.go index a5fd905d..2b07670f 100644 --- a/pkg/hardware_info/mediatek/mediatek.go +++ b/pkg/hardware_info/mediatek/mediatek.go @@ -19,19 +19,18 @@ var socToPlatform = map[string]string{ "mt8189": "genio-520-720", } -func Info() ([]types.PlatformInfo, []types.DetectedDevice, error) { +func Info() ([]types.DetectedDevice, error) { compatibleValues, err := readCompatibleValues(deviceTreeRoot) if err != nil { - return nil, nil, fmt.Errorf("detecting mediatek apusys: %v", err) + return nil, fmt.Errorf("detecting mediatek apusys: %v", err) } - platforms, devices := DetectFromCompatibles(compatibleValues) - return platforms, devices, nil + devices := DetectFromCompatibles(compatibleValues) + return devices, nil } -func DetectFromCompatibles(compatibleValues []string) ([]types.PlatformInfo, []types.DetectedDevice) { +func DetectFromCompatibles(compatibleValues []string) []types.DetectedDevice { platSet := make(map[string]struct{}) - matchSet := make(map[string]struct{}) for _, value := range compatibleValues { soc, ok := extractAPUSoC(value) @@ -45,11 +44,10 @@ func DetectFromCompatibles(compatibleValues []string) ([]types.PlatformInfo, []t } platSet[platformName] = struct{}{} - matchSet[value] = struct{}{} } - if len(matchSet) == 0 { - return nil, nil + if len(platSet) == 0 { + return nil } platformNames := make([]string, 0, len(platSet)) @@ -58,27 +56,19 @@ func DetectFromCompatibles(compatibleValues []string) ([]types.PlatformInfo, []t } sort.Strings(platformNames) - platforms := make([]types.PlatformInfo, 0, len(platformNames)) + devices := make([]types.DetectedDevice, 0, len(platformNames)) for _, name := range platformNames { - platforms = append(platforms, types.PlatformInfo{ - Vendor: "mediatek", - Name: name, + devices = append(devices, types.DetectedDevice{ + Type: "npu", + Bus: "mdla", + Metadata: &types.DeviceMetadata{ + VendorName: "mediatek", + ProductName: name, + }, }) } - matches := make([]string, 0, len(matchSet)) - for value := range matchSet { - matches = append(matches, value) - } - sort.Strings(matches) - - devices := []types.DetectedDevice{{ - Type: "npu", - Bus: "mdla", - Nodes: matches, - }} - - return platforms, devices + return devices } func readCompatibleValues(root string) ([]string, error) { diff --git a/pkg/hardware_info/mediatek/mediatek_test.go b/pkg/hardware_info/mediatek/mediatek_test.go index afdbd568..b996c29d 100644 --- a/pkg/hardware_info/mediatek/mediatek_test.go +++ b/pkg/hardware_info/mediatek/mediatek_test.go @@ -10,7 +10,7 @@ import ( ) func TestDetectFromCompatibles(t *testing.T) { - platforms, devices := DetectFromCompatibles([]string{ + devices := DetectFromCompatibles([]string{ "arm,v8", "mediatek,mt8195-apusys_rv", "mediatek,mt8188-apusys_rv", @@ -19,24 +19,33 @@ func TestDetectFromCompatibles(t *testing.T) { "mediatek,mt8188-apusys_rv", // duplicate should be deduped }) - expectedPlatforms := []types.PlatformInfo{ - {Vendor: "mediatek", Name: "genio-1200"}, - {Vendor: "mediatek", Name: "genio-510-700"}, - {Vendor: "mediatek", Name: "genio-520-720"}, - {Vendor: "mediatek", Name: "mediatek-mt9999"}, - } - if !reflect.DeepEqual(platforms, expectedPlatforms) { - t.Fatalf("platforms=%+v expected=%+v", platforms, expectedPlatforms) - } - expectedDevices := []types.DetectedDevice{{ Type: "npu", Bus: "mdla", - Nodes: []string{ - "mediatek,mt8188-apusys_rv", - "mediatek,mt8189-apusys_rv", - "mediatek,mt8195-apusys_rv", - "mediatek,mt9999-apusys_rv", + Metadata: &types.DeviceMetadata{ + VendorName: "mediatek", + ProductName: "genio-1200", + }, + }, { + Type: "npu", + Bus: "mdla", + Metadata: &types.DeviceMetadata{ + VendorName: "mediatek", + ProductName: "genio-510-700", + }, + }, { + Type: "npu", + Bus: "mdla", + Metadata: &types.DeviceMetadata{ + VendorName: "mediatek", + ProductName: "genio-520-720", + }, + }, { + Type: "npu", + Bus: "mdla", + Metadata: &types.DeviceMetadata{ + VendorName: "mediatek", + ProductName: "mediatek-mt9999", }, }} if !reflect.DeepEqual(devices, expectedDevices) { @@ -70,20 +79,18 @@ func TestInfo(t *testing.T) { t.Fatal(err) } - platforms, devices, err := Info() + devices, err := Info() if err != nil { t.Fatal(err) } - expectedPlatforms := []types.PlatformInfo{{Vendor: "mediatek", Name: "genio-510-700"}} - if !reflect.DeepEqual(platforms, expectedPlatforms) { - t.Fatalf("platforms=%+v expected=%+v", platforms, expectedPlatforms) - } - expectedDevices := []types.DetectedDevice{{ - Type: "npu", - Bus: "mdla", - Nodes: []string{"mediatek,mt8188-apusys_rv"}, + Type: "npu", + Bus: "mdla", + Metadata: &types.DeviceMetadata{ + VendorName: "mediatek", + ProductName: "genio-510-700", + }, }} if !reflect.DeepEqual(devices, expectedDevices) { t.Fatalf("devices=%+v expected=%+v", devices, expectedDevices) @@ -105,11 +112,11 @@ func TestInfoNoMatch(t *testing.T) { t.Fatal(err) } - platforms, devices, err := Info() + devices, err := Info() if err != nil { t.Fatal(err) } - if len(platforms) != 0 || len(devices) != 0 { - t.Fatalf("expected no mediatek npu match, got platforms=%+v devices=%+v", platforms, devices) + if len(devices) != 0 { + t.Fatalf("expected no mediatek npu match, got devices=%+v", devices) } -} \ No newline at end of file +}