Resolve shared HID slot for touchscreen gadget

The upstream wake HID function and the Android touchscreen digitizer both need hid.usb3 on this hardware. The device kernel does not expose hid.usb4, so keep wake_hid enabled only when touchscreen is disabled and route wake behavior through a harmless no-touch touchscreen report when touchscreen owns the slot.

Also preserve enabled config symlinks when a disabled gadget item shares the same config path, which prevents disabled wake_hid from removing the active touchscreen hid.usb3 link during config writes.

Validated with go test ./internal/usbgadget, make build_dev, and a live JetKVM sanity check showing the debug binary hash matched, USB was configured, and hid.usb3 used the touchscreen report length.

Author: Codex

internal/usbgadget/config.go

@@ -77,6 +77,8 @@ func (u *UsbGadget) isGadgetConfigItemEnabled(itemKey string) bool {
 		return u.enabledDevices.RelativeMouse
 	case "keyboard":
 		return u.enabledDevices.Keyboard
+	case "wake_hid":
+		return !u.enabledDevices.Touchscreen
 	case "touchscreen":
 		return u.enabledDevices.Touchscreen
 	case "mass_storage_base":

internal/usbgadget/config_test.go

@@ -1,6 +1,11 @@
 package usbgadget
 
-import "testing"
+import (
+	"strings"
+	"testing"
+
+	"github.com/rs/zerolog"
+)
 
 func TestAudioGadgetConfigFollowsEnabledDevice(t *testing.T) {
 	u := &UsbGadget{enabledDevices: Devices{Audio: false}}
@@ -16,9 +21,113 @@ func TestAudioGadgetConfigFollowsEnabledDevice(t *testing.T) {
 
 func TestBaseGadgetConfigItemsAlwaysEnabled(t *testing.T) {
 	u := &UsbGadget{}
-	for _, item := range []string{"base", "base_info", "wake_hid"} {
+	for _, item := range []string{"base", "base_info"} {
 		if !u.isGadgetConfigItemEnabled(item) {
 			t.Fatalf("%s should always be enabled", item)
 		}
 	}
 }
+
+func TestWakeHIDUsesTouchscreenSlotOnlyWhenTouchscreenDisabled(t *testing.T) {
+	u := &UsbGadget{enabledDevices: Devices{Touchscreen: false}}
+	if !u.isGadgetConfigItemEnabled("wake_hid") {
+		t.Fatal("wake_hid should be enabled when touchscreen is disabled")
+	}
+
+	u.enabledDevices.Touchscreen = true
+	if u.isGadgetConfigItemEnabled("wake_hid") {
+		t.Fatal("wake_hid should be disabled when touchscreen uses the final HID slot")
+	}
+}
+
+func TestEnabledGadgetConfigPathsAreUnique(t *testing.T) {
+	for name, devices := range map[string]Devices{
+		"touchscreen": {
+			AbsoluteMouse: true,
+			RelativeMouse: true,
+			Keyboard:      true,
+			Touchscreen:   true,
+			MassStorage:   true,
+			SerialConsole: true,
+			Audio:         true,
+		},
+		"wake_hid": {
+			AbsoluteMouse: true,
+			RelativeMouse: true,
+			Keyboard:      true,
+			Touchscreen:   false,
+			MassStorage:   true,
+			SerialConsole: true,
+			Audio:         true,
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			assertEnabledGadgetConfigPathsAreUnique(t, devices)
+		})
+	}
+}
+
+func assertEnabledGadgetConfigPathsAreUnique(t *testing.T, devices Devices) {
+	t.Helper()
+
+	u := &UsbGadget{enabledDevices: devices}
+
+	paths := map[string]string{}
+	configPaths := map[string]string{}
+
+	for key, item := range defaultGadgetConfig {
+		if !u.isGadgetConfigItemEnabled(key) {
+			continue
+		}
+
+		if len(item.path) > 0 {
+			pathKey := strings.Join(item.path, "/")
+			if previous, ok := paths[pathKey]; ok {
+				t.Fatalf("%s and %s share gadget path %s", previous, key, pathKey)
+			}
+			paths[pathKey] = key
+		}
+
+		if len(item.configPath) > 0 {
+			configPathKey := strings.Join(item.configPath, "/")
+			if previous, ok := configPaths[configPathKey]; ok {
+				t.Fatalf("%s and %s share gadget config path %s", previous, key, configPathKey)
+			}
+			configPaths[configPathKey] = key
+		}
+	}
+}
+
+func TestDisabledSharedConfigPathIsNotRemovedWhenEnabledItemUsesIt(t *testing.T) {
+	logger := zerolog.Nop()
+	tx := &UsbGadgetTransaction{
+		c:                  &ChangeSet{},
+		log:                &logger,
+		kvmGadgetPath:      "/sys/kernel/config/usb_gadget/test",
+		configC1Path:       "/sys/kernel/config/usb_gadget/test/configs/c.1",
+		orderedConfigItems: orderedGadgetConfigItems{{"wake_hid", wakeHIDConfig}, {"touchscreen", touchscreenConfig}},
+		isGadgetConfigItemEnabled: func(key string) bool {
+			return key == "touchscreen"
+		},
+	}
+
+	tx.WriteGadgetConfig()
+
+	touchscreenConfigPath := "/sys/kernel/config/usb_gadget/test/configs/c.1/hid.usb3"
+	for _, change := range tx.c.Changes {
+		if change.Path == touchscreenConfigPath && change.ExpectedState == FileStateAbsent && change.When == "" {
+			t.Fatalf("disabled wake_hid should not request unconditional removal of enabled touchscreen config path: %s", change.String())
+		}
+	}
+
+	if tx.reorderSymlinkChanges == nil {
+		t.Fatal("expected touchscreen config path to be included in symlink reorder")
+	}
+
+	for _, link := range tx.reorderSymlinkChanges.ParamSymlinks {
+		if link.Path == touchscreenConfigPath {
+			return
+		}
+	}
+	t.Fatalf("expected touchscreen config path %s in symlink reorder", touchscreenConfigPath)
+}

internal/usbgadget/config_tx.go

@@ -152,12 +152,29 @@ func (tx *UsbGadgetTransaction) WriteGadgetConfig() {
 	deps := make([]string, 0)
 	deps = append(deps, tx.kvmGadgetPath)
 
+	enabledConfigPaths := map[string]struct{}{}
+	for _, val := range tx.orderedConfigItems {
+		if !tx.isGadgetConfigItemEnabled(val.key) {
+			continue
+		}
+		if val.item.configPath == nil || val.item.configAttrs != nil {
+			continue
+		}
+		enabledConfigPaths[joinPath(tx.configC1Path, val.item.configPath)] = struct{}{}
+	}
+
 	for _, val := range tx.orderedConfigItems {
 		key := val.key
 		item := val.item
 
 		// check if the item is enabled in the config
 		if !tx.isGadgetConfigItemEnabled(key) {
+			if item.configPath != nil && item.configAttrs == nil {
+				configPath := joinPath(tx.configC1Path, item.configPath)
+				if _, sharedWithEnabledItem := enabledConfigPaths[configPath]; sharedWithEnabledItem {
+					continue
+				}
+			}
 			tx.DisableGadgetItemConfig(item)
 			continue
 		}

internal/usbgadget/hid_keyboard.go

@@ -529,6 +529,10 @@ func (u *UsbGadget) KeyboardReport(modifier byte, keys []byte) error {
 }
 
 func (u *UsbGadget) WakeReport(active bool) error {
+	if u.enabledDevices.Touchscreen {
+		return u.TouchscreenReport(0, 0, false)
+	}
+
 	var report byte
 	if active {
 		report = 1