chore: verify host mode available and enabled

Author: bahaaador

.task/checksum/build

@@ -1 +1 @@
-67563be1715a0a013997a8f9f75637e
+a83c8fc345928bd53180aac00c1667df

.task/checksum/build-debug

@@ -1 +1 @@
-a86696d76dc0e7c46e7da1efaa995964
+a83c8fc345928bd53180aac00c1667df

cmd/bt-hid-relay/main.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"os"
 
+	"github.com/bahaaador/bluetooth-usb-peripheral-relay/internal/device"
 	"github.com/bahaaador/bluetooth-usb-peripheral-relay/internal/logger"
 	"github.com/bahaaador/bluetooth-usb-peripheral-relay/internal/relay"
 )
@@ -26,6 +27,19 @@ func parseFlags() relay.Config {
 func main() {
 	config := parseFlags()
 
+	hasHostCapability, isHostEnabled, err := device.CheckUSBHostSupport()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if !hasHostCapability {
+		log.Fatal("USB Host mode is not supported")
+	}
+
+	if !isHostEnabled {
+		log.Fatal("USB Host mode is not enabled")
+	}
+
 	relay := relay.NewRelay(config)
 	if err := relay.Start(); err != nil {
 		log.Printf("Error: %v", err)

cmd/bt-hid-relay/main_test.go

@@ -146,7 +146,8 @@ func TestMain(t *testing.T) {
 	// Test with default arguments
 	os.Args = []string{"cmd"}
 
-	// Create a channel to capture potential panics
+	// Create channels for synchronization
+	ready := make(chan bool)
 	done := make(chan bool)
 
 	go func() {
@@ -160,9 +161,16 @@ func TestMain(t *testing.T) {
 			done <- true
 		}()
 
-		// Run main
-		go main()
-		time.Sleep(100 * time.Millisecond) // Let main initialize
+		// Run main in a goroutine with synchronization
+		go func() {
+			ready <- true
+			main()
+		}()
+
+		// Wait for main to start
+		<-ready
+		// Give main some time to initialize
+		time.Sleep(100 * time.Millisecond)
 		osExit(0)
 	}()
 

cmd/diagnose-io/main.go

@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"os/signal"
+	"syscall"
 
 	"github.com/bahaaador/bluetooth-usb-peripheral-relay/internal/device"
 	"github.com/bahaaador/bluetooth-usb-peripheral-relay/internal/relay"
@@ -24,6 +26,10 @@ func main() {
 	fmt.Println("Bluetooth Device Verification Tool")
 	fmt.Println("=================================")
 
+	if err := verifyUSBHostSupport(); err != nil {
+		log.Fatal(err)
+	}
+
 	if err := verifyDevices(); err != nil {
 		log.Fatal(err)
 	}
@@ -33,6 +39,28 @@ func main() {
 	}
 }
 
+func verifyUSBHostSupport() error {
+	fmt.Println("\nChecking USB Host Support:")
+	hasHostCapability, isHostEnabled, err := device.CheckUSBHostSupport()
+	if err != nil {
+		return fmt.Errorf("failed to check USB host support: %v", err)
+	}
+
+	if !hasHostCapability {
+		return fmt.Errorf("USB Host mode is not supported")
+	} else {
+		fmt.Printf("%s USB Host mode: supported\n", checkMark)
+	}
+
+	if !isHostEnabled {
+		return fmt.Errorf("USB Host mode is not enabled")
+	} else {
+		fmt.Printf("%s USB Host mode: enabled\n", checkMark)
+	}
+
+	return nil
+}
+
 func verifyDevices() error {
 	// Check HID gadget devices
 	fmt.Println("\nChecking HID gadget devices:")
@@ -94,7 +122,7 @@ func echoDeviceInputs() error {
 
 	// Only start readers for devices that were found
 	if mouseDevice != "" {
-		mouseFile, err := osOpenFile(mouseDevice, os.O_WRONLY, 0666)
+		mouseFile, err := osOpenFile(mouseDevice, os.O_RDONLY, 0666)
 		if err != nil {
 			return fmt.Errorf("failed to open mouse device: %v", err)
 		}
@@ -103,16 +131,21 @@ func echoDeviceInputs() error {
 	}
 
 	if keyboardDevice != "" {
-		keyboardFile, err := osOpenFile(keyboardDevice, os.O_WRONLY, 0666)
+		keyboardFile, err := osOpenFile(keyboardDevice, os.O_RDONLY, 0666)
 		if err != nil {
 			return fmt.Errorf("failed to open keyboard device: %v", err)
 		}
 		defer keyboardFile.Close()
 		go readInput(keyboardFile, "Keyboard")
 	}
 
-	// Keep the program running
-	select {}
+	// Add a channel to handle program termination
+	done := make(chan os.Signal, 1)
+	signal.Notify(done, os.Interrupt, syscall.SIGTERM)
+	
+	// Wait for interrupt signal
+	<-done
+	return nil
 }
 
 func readInput(file *os.File, deviceName string) {

internal/device/host_check.go

@@ -0,0 +1,61 @@
+package device
+
+import (
+	"os"
+	"strings"
+)
+
+// CheckUSBHostSupport verifies both USB host hardware capability and if it's enabled
+func CheckUSBHostSupport() (hasCapability bool, isEnabled bool, err error) {
+	// Check hardware capability first
+	hasCapability = false
+
+	// Check for USB host controller presence
+	if _, err := os.Stat("/sys/class/usb_host"); err == nil {
+		hasCapability = true
+	}
+
+	// Check USB controllers capabilities through kernel info
+	controllers, err := os.ReadFile("/sys/kernel/debug/usb/devices")
+	if err == nil {
+		content := string(controllers)
+		// Look for host controller interfaces (EHCI, XHCI, OHCI)
+		if strings.Contains(content, "Cls=09") || // USB Hub Class
+			strings.Contains(content, "EHCI") ||
+			strings.Contains(content, "XHCI") ||
+			strings.Contains(content, "OHCI") {
+			hasCapability = true
+		}
+	}
+
+	// If no hardware capability, return early
+	if !hasCapability {
+		return hasCapability, false, nil
+	}
+
+	// Check if it's enabled/configured
+	isEnabled = false
+
+	// Check if the device tree has USB OTG support
+	dtOverlay, err := os.ReadFile("/boot/config.txt")
+	if err == nil && strings.Contains(string(dtOverlay), "dtoverlay=dwc2") {
+		isEnabled = true
+	}
+
+	// Check if the necessary modules are loaded
+	modules, err := os.ReadFile("/proc/modules")
+	if err == nil {
+		moduleContent := string(modules)
+		if strings.Contains(moduleContent, "dwc2") &&
+			strings.Contains(moduleContent, "libcomposite") {
+			isEnabled = true
+		}
+	}
+
+	// Check for USB gadget configfs support
+	if _, err := os.Stat("/sys/kernel/config/usb_gadget"); err == nil {
+		isEnabled = true
+	}
+
+	return hasCapability, isEnabled, nil
+}