diff --git a/pkg/engines/busses.go b/pkg/engines/busses.go index 1f2b2869..26158f38 100644 --- a/pkg/engines/busses.go +++ b/pkg/engines/busses.go @@ -12,6 +12,10 @@ func (device Device) validateBus(extraFields []string) error { return device.validatePci(extraFields) case "usb": return device.validateUsb(extraFields) + case "fastrpc": + return device.validateFastRpc(extraFields) + case "drpai": + return device.validateDrpAi(extraFields) case "": // default to pci bus return device.validatePci(extraFields) default: @@ -49,3 +53,61 @@ 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 +} + +func (device Device) validateDrpAi(extraFields []string) error { + if device.Type != "" && device.Type != "npu" { + return fmt.Errorf("drpai 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("drpai: invalid field: %s", fieldName) + } + } + } + + return nil +} diff --git a/pkg/engines/busses_test.go b/pkg/engines/busses_test.go index a8abd686..c77e2929 100644 --- a/pkg/engines/busses_test.go +++ b/pkg/engines/busses_test.go @@ -42,4 +42,22 @@ 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) + }) + + t.Run("DRP-AI bus with non-NPU type", func(t *testing.T) { + device.Bus = "drpai" + err := device.validate() + if err == nil { + t.Fatal("DRP-AI 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..8817eb08 100644 --- a/pkg/engines/devices_test.go +++ b/pkg/engines/devices_test.go @@ -130,6 +130,52 @@ 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) + }) + + t.Run("NPU drpai valid fields", func(t *testing.T) { + device = Device{Type: "npu", Bus: "drpai"} + nodeGlob := "/dev/drpai*" + device.NodeGlob = &nodeGlob + + err := device.validate() + if err != nil { + t.Fatalf("NPU drpai fields should be valid: %v", err) + } + }) + + t.Run("NPU drpai invalid fields", func(t *testing.T) { + device = Device{Type: "npu", Bus: "drpai"} + hexValue := types.HexInt(0xAA) + device.VendorId = &hexValue + + err := device.validate() + if err == nil { + t.Fatal("NPU drpai 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 a87bd62c..f2502b5a 100644 --- a/pkg/hardware_info/hardware-info.go +++ b/pkg/hardware_info/hardware-info.go @@ -4,12 +4,16 @@ 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/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" + "github.com/canonical/inference-snaps-cli/pkg/hardware_info/renesas" "github.com/canonical/inference-snaps-cli/pkg/types" ) @@ -40,6 +44,24 @@ func Get(friendlyNames bool) (*types.HwInfo, []string, error) { } hwInfo.PciDevices = pciDevices + qualcommDevices, err := qualcomm.Info() + if err != nil { + return nil, nil, fmt.Errorf("getting qualcomm devices: %v", err) + } + hwInfo.Devices = append(hwInfo.Devices, qualcommDevices...) + + mediatekDevices, err := mediatek.Info() + if err != nil { + return nil, nil, fmt.Errorf("getting mediatek devices: %v", err) + } + hwInfo.Devices = append(hwInfo.Devices, mediatekDevices...) + + renesasDevices, err := renesas.Info() + if err != nil { + return nil, nil, fmt.Errorf("getting renesas devices: %v", err) + } + hwInfo.Devices = append(hwInfo.Devices, renesasDevices...) + return &hwInfo, warnings, nil } @@ -100,6 +122,47 @@ 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)) + devices := qualcomm.DetectFromNodes(nodes) + hwInfo.Devices = devices + } else if !os.IsNotExist(err) { + 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) + } + + drpAiNodesFile := devicePath + "drpai-nodes.txt" + if _, err := os.Stat(drpAiNodesFile); err == nil { + nodesData, err := os.ReadFile(drpAiNodesFile) + if err != nil { + t.Fatal(err) + } + + nodes := strings.Fields(string(nodesData)) + devices := renesas.DetectFromNodes(nodes) + hwInfo.Devices = append(hwInfo.Devices, devices...) + } else if !os.IsNotExist(err) { + t.Fatalf("error checking file '%s': %v\n", drpAiNodesFile, 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..2b07670f --- /dev/null +++ b/pkg/hardware_info/mediatek/mediatek.go @@ -0,0 +1,131 @@ +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.DetectedDevice, error) { + compatibleValues, err := readCompatibleValues(deviceTreeRoot) + if err != nil { + return nil, fmt.Errorf("detecting mediatek apusys: %v", err) + } + + devices := DetectFromCompatibles(compatibleValues) + return devices, nil +} + +func DetectFromCompatibles(compatibleValues []string) []types.DetectedDevice { + platSet := 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{}{} + } + + if len(platSet) == 0 { + return nil + } + + platformNames := make([]string, 0, len(platSet)) + for name := range platSet { + platformNames = append(platformNames, name) + } + sort.Strings(platformNames) + + devices := make([]types.DetectedDevice, 0, len(platformNames)) + for _, name := range platformNames { + devices = append(devices, types.DetectedDevice{ + Type: "npu", + Bus: "mdla", + Metadata: &types.DeviceMetadata{ + VendorName: "mediatek", + ProductName: name, + }, + }) + } + + return 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..b996c29d --- /dev/null +++ b/pkg/hardware_info/mediatek/mediatek_test.go @@ -0,0 +1,122 @@ +package mediatek + +import ( + "os" + "path/filepath" + "reflect" + "testing" + + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +func TestDetectFromCompatibles(t *testing.T) { + 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 + }) + + expectedDevices := []types.DetectedDevice{{ + Type: "npu", + Bus: "mdla", + 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) { + 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) + } + + devices, err := Info() + if err != nil { + t.Fatal(err) + } + + expectedDevices := []types.DetectedDevice{{ + 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) + } +} + +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) + } + + devices, err := Info() + if err != nil { + t.Fatal(err) + } + if len(devices) != 0 { + t.Fatalf("expected no mediatek npu match, got devices=%+v", devices) + } +} diff --git a/pkg/hardware_info/qualcomm/qualcomm.go b/pkg/hardware_info/qualcomm/qualcomm.go new file mode 100644 index 00000000..08d7bb93 --- /dev/null +++ b/pkg/hardware_info/qualcomm/qualcomm.go @@ -0,0 +1,71 @@ +package qualcomm + +import ( + "fmt" + "path/filepath" + "sort" + "strings" + + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +var devRoot = "/dev" + +func Info() ([]types.DetectedDevice, error) { + nodes, err := globSorted(filepath.Join(devRoot, "fastrpc-*")) + if err != nil { + return nil, fmt.Errorf("detecting fastrpc nodes: %v", err) + } + + return DetectFromNodes(nodes), nil +} + +func DetectFromNodes(nodes []string) []types.DetectedDevice { + var devices []types.DetectedDevice + + for _, node := range nodes { + node = strings.TrimSpace(node) + if node == "" { + continue + } + + base := filepath.Base(node) + if !strings.HasPrefix(base, "fastrpc-") { + continue + } + + devices = append(devices, types.DetectedDevice{ + Type: detectNpuType(base), + Bus: "fastrpc", + Metadata: &types.DeviceMetadata{ + VendorName: "qualcomm", + ProductName: node, + }, + }) + } + + sort.Slice(devices, func(i, j int) bool { + return devices[i].Metadata.ProductName < devices[j].Metadata.ProductName + }) + + 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) { + 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..d189e526 --- /dev/null +++ b/pkg/hardware_info/qualcomm/qualcomm_test.go @@ -0,0 +1,109 @@ +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) + } + + devices, err := Info() + if err != nil { + t.Fatal(err) + } + + expectedDevices := []types.DetectedDevice{ + { + Type: "NPU - adsp-secure", + Bus: "fastrpc", + Metadata: &types.DeviceMetadata{ + VendorName: "qualcomm", + ProductName: filepath.Join(tmp, "fastrpc-adsp-secure"), + }, + }, + { + Type: "NPU - cdsp", + Bus: "fastrpc", + Metadata: &types.DeviceMetadata{ + VendorName: "qualcomm", + ProductName: filepath.Join(tmp, "fastrpc-cdsp"), + }, + }, + { + Type: "NPU - cdsp1", + Bus: "fastrpc", + Metadata: &types.DeviceMetadata{ + VendorName: "qualcomm", + ProductName: 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", + } + + devices := DetectFromNodes(nodes) + + expectedDevices := []types.DetectedDevice{ + { + Type: "NPU - adsp", + Bus: "fastrpc", + Metadata: &types.DeviceMetadata{ + VendorName: "qualcomm", + ProductName: "/dev/fastrpc-adsp", + }, + }, + { + Type: "NPU - cdsp", + Bus: "fastrpc", + Metadata: &types.DeviceMetadata{ + VendorName: "qualcomm", + ProductName: "/dev/fastrpc-cdsp", + }, + }, + { + Type: "NPU - cdsp1-secure", + Bus: "fastrpc", + Metadata: &types.DeviceMetadata{ + VendorName: "qualcomm", + ProductName: "/dev/fastrpc-cdsp1-secure", + }, + }, + } + + if !reflect.DeepEqual(devices, expectedDevices) { + t.Fatalf("devices=%+v expected=%+v", devices, expectedDevices) + } +} diff --git a/pkg/hardware_info/renesas/renesas.go b/pkg/hardware_info/renesas/renesas.go new file mode 100644 index 00000000..e6f14c67 --- /dev/null +++ b/pkg/hardware_info/renesas/renesas.go @@ -0,0 +1,62 @@ +package renesas + +import ( + "fmt" + "path/filepath" + "sort" + "strings" + + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +var devRoot = "/dev" + +func Info() ([]types.DetectedDevice, error) { + nodes, err := globSorted(filepath.Join(devRoot, "drpai*")) + if err != nil { + return nil, fmt.Errorf("detecting drpai nodes: %v", err) + } + + return DetectFromNodes(nodes), nil +} + +func DetectFromNodes(nodes []string) []types.DetectedDevice { + var devices []types.DetectedDevice + + for _, node := range nodes { + node = strings.TrimSpace(node) + if node == "" { + continue + } + + base := filepath.Base(node) + if !strings.HasPrefix(base, "drpai") { + continue + } + + devices = append(devices, types.DetectedDevice{ + Type: "npu", + Bus: "drpai", + Metadata: &types.DeviceMetadata{ + VendorName: "renesas", + ProductName: node, + }, + }) + } + + sort.Slice(devices, func(i, j int) bool { + return devices[i].Metadata.ProductName < devices[j].Metadata.ProductName + }) + + return 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/renesas/renesas_test.go b/pkg/hardware_info/renesas/renesas_test.go new file mode 100644 index 00000000..dd38843b --- /dev/null +++ b/pkg/hardware_info/renesas/renesas_test.go @@ -0,0 +1,92 @@ +package renesas + +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, "drpai1")) + if err != nil { + t.Fatal(err) + } + _, err = os.Create(filepath.Join(tmp, "drpai0")) + if err != nil { + t.Fatal(err) + } + _, err = os.Create(filepath.Join(tmp, "something-else")) + if err != nil { + t.Fatal(err) + } + + devices, err := Info() + if err != nil { + t.Fatal(err) + } + + expectedDevices := []types.DetectedDevice{ + { + Type: "npu", + Bus: "drpai", + Metadata: &types.DeviceMetadata{ + VendorName: "renesas", + ProductName: filepath.Join(tmp, "drpai0"), + }, + }, + { + Type: "npu", + Bus: "drpai", + Metadata: &types.DeviceMetadata{ + VendorName: "renesas", + ProductName: filepath.Join(tmp, "drpai1"), + }, + }, + } + if !reflect.DeepEqual(devices, expectedDevices) { + t.Fatalf("devices=%+v expected=%+v", devices, expectedDevices) + } +} + +func TestDetectFromNodes(t *testing.T) { + nodes := []string{ + "/dev/drpai1", + "/dev/something-else", + "/dev/drpai0", + } + + devices := DetectFromNodes(nodes) + + expectedDevices := []types.DetectedDevice{ + { + Type: "npu", + Bus: "drpai", + Metadata: &types.DeviceMetadata{ + VendorName: "renesas", + ProductName: "/dev/drpai0", + }, + }, + { + Type: "npu", + Bus: "drpai", + Metadata: &types.DeviceMetadata{ + VendorName: "renesas", + ProductName: "/dev/drpai1", + }, + }, + } + + if !reflect.DeepEqual(devices, expectedDevices) { + t.Fatalf("devices=%+v expected=%+v", devices, expectedDevices) + } +} diff --git a/pkg/selector/drpai/drpai.go b/pkg/selector/drpai/drpai.go new file mode 100644 index 00000000..203e6585 --- /dev/null +++ b/pkg/selector/drpai/drpai.go @@ -0,0 +1,59 @@ +package drpai + +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/drpai*" + +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 != "drpai" { + continue + } + if manifestDevice.Type != "" && manifestDevice.Type != hostDevice.Type { + continue + } + if hostDevice.Metadata == nil || hostDevice.Metadata.ProductName == "" { + continue + } + + matched, err := filepath.Match(nodeGlob, hostDevice.Metadata.ProductName) + 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/drpai/drpai_test.go b/pkg/selector/drpai/drpai_test.go new file mode 100644 index 00000000..5201e2ed --- /dev/null +++ b/pkg/selector/drpai/drpai_test.go @@ -0,0 +1,77 @@ +package drpai + +import ( + "strings" + "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: "drpai", + Metadata: &types.DeviceMetadata{ + VendorName: "renesas", + ProductName: "/dev/drpai0", + }, + }, + } + + device := engines.Device{Type: "npu", Bus: "drpai"} + score, issues := Match(device, hostDevices) + if len(issues) > 0 { + t.Fatalf("expected match, got issues=%v", issues) + } + if score <= 0 { + t.Fatalf("expected positive score, got %d", score) + } +} + +func TestMatchWithNodeGlob(t *testing.T) { + hostDevices := []types.DetectedDevice{ + { + Type: "npu", + Bus: "drpai", + Metadata: &types.DeviceMetadata{ + VendorName: "renesas", + ProductName: "/dev/drpai0", + }, + }, + } + + nodeGlob := "/dev/drpai1" + device := engines.Device{Type: "npu", Bus: "drpai", NodeGlob: &nodeGlob} + score, issues := Match(device, hostDevices) + if score != 0 { + t.Fatalf("expected zero score, got %d", score) + } + if len(issues) == 0 || !strings.Contains(issues[0], "device node matching") { + t.Fatalf("expected node matching issue, got %v", issues) + } +} + +func TestMatchInvalidNodeGlob(t *testing.T) { + hostDevices := []types.DetectedDevice{ + { + Type: "npu", + Bus: "drpai", + Metadata: &types.DeviceMetadata{ + VendorName: "renesas", + ProductName: "/dev/drpai0", + }, + }, + } + + nodeGlob := "[" + device := engines.Device{Type: "npu", Bus: "drpai", NodeGlob: &nodeGlob} + score, issues := Match(device, hostDevices) + if score != 0 { + t.Fatalf("expected zero score, got %d", score) + } + if len(issues) == 0 || !strings.Contains(issues[0], "invalid node-glob") { + t.Fatalf("expected invalid node glob issue, got %v", issues) + } +} diff --git a/pkg/selector/drpai_test.go b/pkg/selector/drpai_test.go new file mode 100644 index 00000000..6008f9e2 --- /dev/null +++ b/pkg/selector/drpai_test.go @@ -0,0 +1,53 @@ +package selector + +import ( + "testing" + + "github.com/canonical/inference-snaps-cli/pkg/engines" + "github.com/canonical/inference-snaps-cli/pkg/types" +) + +func TestDrpAiNpuSelection(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: "drpai", + Metadata: &types.DeviceMetadata{ + VendorName: "renesas", + ProductName: "/dev/drpai0", + }, + }, + }, + } + + manifest := engines.Manifest{ + Name: "renesas-npu", + Description: "renesas drp-ai npu", + Vendor: "renesas", + Grade: "stable", + Devices: engines.Devices{ + Anyof: []engines.Device{{ + Type: "npu", + Bus: "drpai", + }}, + }, + } + + 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/fastrpc/fastrpc.go b/pkg/selector/fastrpc/fastrpc.go new file mode 100644 index 00000000..ba0111be --- /dev/null +++ b/pkg/selector/fastrpc/fastrpc.go @@ -0,0 +1,79 @@ +package fastrpc + +import ( + "fmt" + "path/filepath" + "strings" + "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 !deviceTypeMatch(manifestDevice.Type, hostDevice.Type) { + continue + } + if hostDevice.Metadata == nil || hostDevice.Metadata.ProductName == "" { + continue + } + + matched, err := filepath.Match(nodeGlob, hostDevice.Metadata.ProductName) + 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)} +} + +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 new file mode 100644 index 00000000..1c849e1d --- /dev/null +++ b/pkg/selector/fastrpc/fastrpc_test.go @@ -0,0 +1,58 @@ +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", + Metadata: &types.DeviceMetadata{ + VendorName: "qualcomm", + ProductName: "/dev/fastrpc-cdsp", + }, + }, + { + Type: "npu", + Bus: "fastrpc", + Metadata: &types.DeviceMetadata{ + VendorName: "qualcomm", + ProductName: "/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..7f5796c7 --- /dev/null +++ b/pkg/selector/fastrpc_test.go @@ -0,0 +1,53 @@ +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", + Metadata: &types.DeviceMetadata{ + VendorName: "qualcomm", + ProductName: "/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..57c13ca0 100644 --- a/pkg/selector/select_stack.go +++ b/pkg/selector/select_stack.go @@ -8,6 +8,8 @@ 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/drpai" + "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 +167,24 @@ 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 == "drpai" { + drpAiScore, drpAiIssues := drpai.Match(devices[i], hardwareInfo.Devices) + if len(drpAiIssues) > 0 { + compatible = false + devices[i].CompatibilityIssues = append(devices[i].CompatibilityIssues, drpAiIssues...) + } else { + compatibilityScore += drpAiScore + } + } 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 +224,24 @@ 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 == "drpai" { + drpAiScore, drpAiIssues := drpai.Match(device, hardwareInfo.Devices) + if len(drpAiIssues) > 0 { + devices[i].CompatibilityIssues = append(device.CompatibilityIssues, drpAiIssues...) + } else { + devicesFound++ + compatibilityScore += drpAiScore + } + } 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..6595cadc --- /dev/null +++ b/pkg/types/detected_devices.go @@ -0,0 +1,12 @@ +package types + +type DeviceMetadata struct { + VendorName string `json:"vendor_name" yaml:"vendor_name"` + ProductName string `json:"product_name,omitempty" yaml:"product_name,omitempty"` +} + +type DetectedDevice struct { + Type string `json:"type" yaml:"type"` + Bus string `json:"bus" yaml:"bus"` + Metadata *DeviceMetadata `json:"metadata,omitempty" yaml:"metadata,omitempty"` +} diff --git a/pkg/types/hw_info.go b/pkg/types/hw_info.go index 9548c730..a8acc817 100644 --- a/pkg/types/hw_info.go +++ b/pkg/types/hw_info.go @@ -5,4 +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"` + 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 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