addons/intel: Introduce gnss.disabled flag to disable e825 incoming GNSS for BC profiles

Signed-off-by: Jim Ramsay <[email protected]>

Author: lack

addons/intel/e825.go

@@ -3,6 +3,7 @@ package intel
 import (
 	"encoding/binary"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"os"
 	"os/exec"
@@ -27,6 +28,12 @@ type E825Opts struct {
 	DpllSettings        map[string]uint64            `json:"settings"`
 	PhaseOffsetPins     map[string]map[string]string `json:"phaseOffsetPins"`
 	PhaseInputs         []PhaseInputs                `json:"interconnections"`
+	Gnss                GnssOptions                  `json:"gnss"`
+}
+
+// GnssOptions defines GNSS-specific options for the e825
+type GnssOptions struct {
+	Disabled bool `json:"disabled"`
 }
 
 // GetPhaseInputs implements PhaseInputsProvider
@@ -35,6 +42,7 @@ func (o E825Opts) GetPhaseInputs() []PhaseInputs { return o.PhaseInputs }
 // E825PluginData is the data structure for e825 plugin
 type E825PluginData struct {
 	hwplugins *[]string
+	dpllPins  []*dpll_netlink.PinInfo
 }
 
 // EnableE825PTPConfig is the script to enable default e825 PTP configuration
@@ -46,7 +54,8 @@ echo "No E825 specific configuration is needed"
 `
 
 // OnPTPConfigChangeE825 performs actions on PTP config change for e825 plugin
-func OnPTPConfigChangeE825(_ *interface{}, nodeProfile *ptpv1.PtpProfile) error {
+func OnPTPConfigChangeE825(data *interface{}, nodeProfile *ptpv1.PtpProfile) error {
+	pluginData := (*data).(*E825PluginData)
 	glog.Info("calling onPTPConfigChange for e825 plugin")
 	var e825Opts E825Opts
 	var err error
@@ -148,11 +157,67 @@ func OnPTPConfigChangeE825(_ *interface{}, nodeProfile *ptpv1.PtpProfile) error
 			} else {
 				glog.Error("no clock chain set")
 			}
+			// Always enforce GNSS setting (default = enabled)
+			pluginData.setupGnss(e825Opts.Gnss)
 		}
 	}
 	return nil
 }
 
+func (d *E825PluginData) populateDpllPins() error {
+	if unitTest {
+		return nil
+	}
+	conn, err := dpll_netlink.Dial(nil)
+	if err != nil {
+		return fmt.Errorf("failed to dial DPLL: %w", err)
+	}
+	defer conn.Close()
+	d.dpllPins, err = conn.DumpPinGet()
+	if err != nil {
+		return fmt.Errorf("failed to dump DPLL pins: %w", err)
+	}
+	return nil
+}
+
+// Setup mockable pin setting function
+var e825DoPinSet = BatchPinSet
+
+func (d *E825PluginData) setupGnss(gnss GnssOptions) error {
+	if len(d.dpllPins) == 0 {
+		err := d.populateDpllPins()
+		if err != nil {
+			return fmt.Errorf("could not detect any DPLL pins: %w", err)
+		}
+	}
+	priority := uint8(PriorityEnabled)
+	action := "enable"
+	if gnss.Disabled {
+		priority = uint8(PriorityDisabled)
+		action = "disable"
+	}
+	commands := []dpll_netlink.PinParentDeviceCtl{}
+	affectedPins := []string{}
+	for _, pin := range d.dpllPins {
+		// Look for all GNSS pins whose priority can be changed
+		if pin.Type == dpll_netlink.PinTypeGNSS &&
+			(pin.Capabilities&dpll_netlink.PinCapPrio != 0) {
+			command := SetPinControlData(*pin, PinParentControl{
+				EecPriority: priority,
+				PpsPriority: priority,
+			})
+			commands = append(commands, *command)
+			affectedPins = append(affectedPins, pin.BoardLabel)
+		}
+	}
+	if len(commands) == 0 {
+		glog.Errorf("Could not locate any GNSS pins to %s", action)
+		return errors.New("no GNSS pins found")
+	}
+	glog.Infof("Will %s %d GNSS pins: %v", action, len(commands), affectedPins)
+	return e825DoPinSet(&commands)
+}
+
 // AfterRunPTPCommandE825 performs actions after certain PTP commands for e825 plugin
 func AfterRunPTPCommandE825(data *interface{}, nodeProfile *ptpv1.PtpProfile, command string) error {
 	pluginData := (*data).(*E825PluginData)

addons/intel/e825_test.go

@@ -4,6 +4,7 @@ import (
 	"slices"
 	"testing"
 
+	dpll "github.com/k8snetworkplumbingwg/linuxptp-daemon/pkg/dpll-netlink"
 	ptpv1 "github.com/k8snetworkplumbingwg/ptp-operator/api/v1"
 	"github.com/stretchr/testify/assert"
 )
@@ -88,3 +89,134 @@ func Test_PopulateHwConfdigE825(t *testing.T) {
 	},
 		output)
 }
+
+type mockBatchPinSet struct {
+	commands *[]dpll.PinParentDeviceCtl
+}
+
+func (m *mockBatchPinSet) mock(commands *[]dpll.PinParentDeviceCtl) error {
+	m.commands = commands
+	return nil
+}
+
+func Test_setupGnss(t *testing.T) {
+	unitTest = true
+	tcs := []struct {
+		name             string
+		gnss             GnssOptions
+		dpll             []*dpll.PinInfo
+		expectError      bool
+		expectedCmdCount int
+	}{
+		{
+			name:        "No DPLL Pins",
+			dpll:        []*dpll.PinInfo{},
+			expectError: true,
+		},
+		{
+			name: "No matching GNSS Pins",
+			dpll: []*dpll.PinInfo{
+				{
+					ID:           1,
+					BoardLabel:   "SkipMe",
+					Type:         dpll.PinTypeEXT,
+					Capabilities: dpll.PinCapPrio,
+				},
+				{
+					ID:           2,
+					BoardLabel:   "SkipMe-Too",
+					Type:         dpll.PinTypeGNSS,
+					Capabilities: 0,
+				},
+			},
+			expectError: true,
+		},
+		{
+			name: "Single matching pin (enable)",
+			gnss: GnssOptions{
+				Disabled: false,
+			},
+			dpll: []*dpll.PinInfo{
+				{
+					ID:           1,
+					BoardLabel:   "SkipMe",
+					Type:         dpll.PinTypeEXT,
+					Capabilities: dpll.PinCapPrio,
+				},
+				{
+					BoardLabel:   "GNSS_1PPS_IN",
+					ID:           2,
+					Type:         dpll.PinTypeGNSS,
+					Capabilities: dpll.PinCapPrio | dpll.PinCapState,
+					ParentDevice: []dpll.PinParentDevice{
+						{
+							ParentID:  uint32(1),
+							Direction: dpll.PinDirectionInput,
+						},
+						{
+							ParentID:  uint32(2),
+							Direction: dpll.PinDirectionInput,
+						},
+					},
+				},
+			},
+			expectedCmdCount: 1,
+		},
+		{
+			name: "Single matching pin (disable)",
+			gnss: GnssOptions{
+				Disabled: true,
+			},
+			dpll: []*dpll.PinInfo{
+				{
+					ID:           1,
+					Type:         dpll.PinTypeEXT,
+					Capabilities: dpll.PinCapPrio,
+				},
+				{
+					ID:           2,
+					Type:         dpll.PinTypeGNSS,
+					Capabilities: dpll.PinCapPrio | dpll.PinCapState,
+					ParentDevice: []dpll.PinParentDevice{
+						{
+							ParentID:  uint32(1),
+							Direction: dpll.PinDirectionInput,
+						},
+						{
+							ParentID:  uint32(2),
+							Direction: dpll.PinDirectionInput,
+						},
+					},
+				},
+			},
+			expectedCmdCount: 1,
+		},
+	}
+	for _, tc := range tcs {
+		t.Run(tc.name, func(tt *testing.T) {
+			mockPinSet := mockBatchPinSet{}
+			e825DoPinSet = mockPinSet.mock
+			data := E825PluginData{
+				dpllPins: tc.dpll,
+			}
+			err := data.setupGnss(tc.gnss)
+			if tc.expectError {
+				assert.Error(tt, err)
+			} else {
+				assert.NoError(tt, err)
+				assert.Equal(tt, tc.expectedCmdCount, len(*mockPinSet.commands))
+				expectedPriority := uint32(PriorityEnabled)
+				if tc.gnss.Disabled {
+					expectedPriority = uint32(PriorityDisabled)
+				}
+				for _, cmd := range *mockPinSet.commands {
+					for _, ctrl := range cmd.PinParentCtl {
+						tt.Logf("Do the thing: %v", ctrl)
+						tt.Logf("Do the thing: %v", ctrl)
+						assert.Equal(tt, expectedPriority, *ctrl.Prio)
+					}
+				}
+			}
+		})
+	}
+}