Add wheel WASD

README.md

@@ -1,5 +1,62 @@
+# Device Drivers
+----------------------------------
 
-Device Driver
+This repository contains Linux **kernel modules** (``.ko``) that implement low-level USB input drivers and expose device events through the Linux **input subsystem** (evdev).
-=============
 
-[Logitech G29 USB Protocol](logitech-G29.md)
+A helper tool (``usb_driver_manager.py``) is included to make it easier to:
+- list USB devices and their **interfaces**
+- load/unload (reload) a chosen ``.ko`` module
+- unbind/bind a selected interface to a chosen driver during development
+
+## Drivers
+----------
+
+### Mouse driver (``mouse/``)
+USB HID boot-protocol mouse driver.
+
+**Build:**
+```bash
+cd mouse
+make
+```
+
+### Logitech G29 media driver (``g29_media_usb/``)
+Logitech G29 driver that maps selected wheel inputs to media key events.
+
+**Current mapping (Mode 0):**
+- Red rotary clockwise / counter-clockwise  -> Volume Up / Volume Down
+- Return ("Enter")                          -> Play/Pause
+- Plus / Minus                              -> Next track / Previous track
+
+**Build:**
+```bash
+cd g29_media_usb
+make
+```
+
+After building, the module (``*.ko``) is typically placed under ``build/`` by the provided Makefiles.
+
+## USB Driver Manager
+---------------------
+
+**Usage examples:**
+```bash
+# Search for modules in these driver directories (the tool searches recursively)
+sudo python3 usb_driver_manager.py ./mouse ./g29_media_usb
+
+# Or point directly at build/ directories
+sudo python3 usb_driver_manager.py ./mouse/build ./g29_media_usb/build
+```
+
+**Workflow:**
+1. Select the USB device.
+2. (Optional but recommended for non-mouse devices) select the USB **interface** to bind.
+3. Select the kernel module.
+4. Confirm; the tool unbinds the current driver, reloads the module if needed, and binds the chosen interface.
+
+## Testing
+----------
+After binding the driver, use ``evtest`` to confirm key events:
+```bash
+sudo evtest
+```

g29-wheel/Makefile

@@ -0,0 +1,14 @@
+
+.PHONY: all clean install uninstall
+
+obj-m += g29_usb.o
+PWD := $(CURDIR)
+
+all:
+	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
+	mkdir -p build
+	-mv -f -- *.ko *.mod.c *.o .*.o *.mod modules.order .*.cmd *.symvers build/
+
+clean:
+	$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
+	rm -rf build

g29-wheel/g29_usb.c

@@ -0,0 +1,326 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Logitech G29 -> Media Keys (USB interface driver)
+ *
+ * Proof-of-concept Linux kernel module for low-level programming course.
+ *
+ * This driver:
+ *   - Binds to a Logitech G29 USB interface (VID/PID match)
+ *   - Receives 12-byte input reports via an interrupt-IN URB
+ *   - Parses the report into a normalized state (Stage A)
+ *   - Translates selected signals into media key events (Stage B)
+ *
+ * Stage A is designed to remain stable across different mapping policies.
+ * Stage B is designed to be replaced/extended by swapping mapping tables
+ * or adding per-signal handler functions.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/usb/input.h>
+#include <linux/input.h>
+#include <linux/timer.h>
+#include <linux/jiffies.h>
+#include <linux/hid.h>
+
+MODULE_AUTHOR("LLP group 16");
+MODULE_DESCRIPTION("Logitech G29 USB driver");
+MODULE_LICENSE("GPL");
+
+#define USB_VENDOR_ID_LOGITECH      0x046d
+#define USB_DEVICE_ID_LOGITECH_G29  0xc24f
+#define USB_DEVICE_ID_LOGITECH_G29_ALT 0xc260
+
+#define G29_BTN_PLUS        0x00800000u
+#define G29_BTN_MINUS       0x01000000u
+#define G29_BTN_RED_CW      0x02000000u
+#define G29_BTN_RED_CCW     0x04000000u
+#define G29_BTN_RETURN      0x08000000u
+#define G29_BTN_R1          0x00000100u
+#define G29_BTN_L1          0x00000200u
+
+enum g29_mode {
+	G29_MODE_MEDIA = 0,
+};
+
+static int mode = G29_MODE_MEDIA;
+module_param(mode, int, 0444);
+MODULE_PARM_DESC(mode, "Mapping mode (0=MEDIA)");
+
+struct g29_state {
+	u32 buttons_le;
+	u16 rot_le;
+	u8 gas;
+	u8 brk;
+	u8 clt;
+	u8 gr_x;
+	u8 gr_y;
+	u8 gr_z;
+};
+
+struct g29_keymap_edge {
+	u32 mask;
+	unsigned short keycode;
+};
+
+static const struct g29_keymap_edge g29_media_edge_map[] = {
+	/* Red rotary = volume */
+	{ G29_BTN_RED_CW,  KEY_VOLUMEUP },
+	{ G29_BTN_RED_CCW, KEY_VOLUMEDOWN },
+
+	/* Return = play/pause */
+	{ G29_BTN_RETURN,  KEY_PLAYPAUSE },
+
+	/* Plus/Minus = next/prev */
+	{ G29_BTN_R1,    KEY_NEXTSONG },
+	{ G29_BTN_L1,   KEY_PREVIOUSSONG },
+};
+
+struct g29_dev {
+	char name[128];
+	char phys[64];
+
+	struct usb_device *udev;
+	struct input_dev *input;
+
+	struct urb *urb;
+	u8 *buf;
+	dma_addr_t buf_dma;
+	int maxp;
+	int interval;
+	int endpoint;
+
+	struct timer_list steer_timer;
+	u32 steer_phase_ms;
+
+	struct g29_state last;
+};
+
+
+static void g29_steer_timer_fn(struct timer_list *t) {
+	struct g29_dev *g29 = timer_container_of(g29, t, steer_timer);
+
+	const int rot = le16_to_cpu(g29->last.rot_le);
+
+	input_report_key(g29->input, KEY_W, g29->last.gas <= 0x80);
+	input_report_key(g29->input, KEY_S, g29->last.clt <= 0x80);
+	input_report_key(g29->input, KEY_A, rot <= 0x6000);
+	input_report_key(g29->input, KEY_D, rot >= 0xA000);
+
+	mod_timer(&g29->steer_timer, jiffies + msecs_to_jiffies(2));
+}
+
+static void g29_apply_media_mode(struct g29_dev *g29, const struct g29_state *cur, const struct g29_state *prev) {
+	u32 pressed = le32_to_cpu(cur->buttons_le & ~prev->buttons_le);
+	for (int i = 0; i < ARRAY_SIZE(g29_media_edge_map); i++) {
+		const struct g29_keymap_edge *e = &g29_media_edge_map[i];
+		if (pressed & e->mask) {
+			input_report_key(g29->input, e->keycode, 1);
+			input_report_key(g29->input, e->keycode, 0);
+		}
+	}
+
+	input_sync(g29->input);
+}
+
+static void g29_process_report(struct g29_dev *g29, const u8 *data, unsigned int len) {
+	if (len < 12) return;
+
+	struct g29_state *cur = (void *) data;
+	switch (mode) {
+	case G29_MODE_MEDIA:
+	default:
+		g29_apply_media_mode(g29, cur, &g29->last);
+		break;
+	}
+
+	g29->last = *cur;
+}
+
+static void g29_urb_complete(struct urb *urb) {
+	struct g29_dev *g29 = urb->context;
+	int ret;
+
+	switch (urb->status) {
+	case 0:
+		break; /* success */
+	case -ECONNRESET:
+	case -ENOENT:
+	case -ESHUTDOWN:
+		return; /* cancelled/disconnected */
+	default:
+		goto resubmit; /* transient error */
+	}
+
+	g29_process_report(g29, g29->buf, urb->actual_length);
+
+resubmit:
+	ret = usb_submit_urb(urb, GFP_ATOMIC);
+	if (ret)
+		dev_err(&g29->udev->dev, "usb_submit_urb failed: %d\n", ret);
+}
+
+static int g29_input_open(struct input_dev *input) {
+	struct g29_dev *g29 = input_get_drvdata(input);
+
+	g29->urb->dev = g29->udev;
+	if (usb_submit_urb(g29->urb, GFP_KERNEL))
+		return -EIO;
+
+	mod_timer(&g29->steer_timer, jiffies + msecs_to_jiffies(2));
+
+	return 0;
+}
+
+static void g29_input_close(struct input_dev *input) {
+	struct g29_dev *g29 = input_get_drvdata(input);
+	timer_delete_sync(&g29->steer_timer);
+	usb_kill_urb(g29->urb);
+}
+
+static int g29_probe(struct usb_interface *intf, const struct usb_device_id *id) {
+	struct usb_device *udev = interface_to_usbdev(intf);
+	int ret;
+
+	/* Find an interrupt IN endpoint capable of carrying the 12-byte report. */
+	struct usb_endpoint_descriptor *ep = NULL;
+	const struct usb_host_interface *alts = intf->cur_altsetting;
+	for (int i = 0; i < alts->desc.bNumEndpoints; i++) {
+		struct usb_endpoint_descriptor *d = &alts->endpoint[i].desc;
+		if (!usb_endpoint_is_int_in(d))
+			continue;
+		if (usb_maxpacket(udev, usb_rcvintpipe(udev, d->bEndpointAddress)) >= 12) {
+			ep = d;
+			break;
+		}
+	}
+	if (!ep) return -ENODEV;
+
+	struct g29_dev *g29;
+	if ((g29 = kzalloc(sizeof(*g29), GFP_KERNEL)) == NULL) {
+		return -ENOMEM;
+	}
+
+	struct input_dev *input;
+	if ((input = input_allocate_device()) == NULL) {
+		ret = -ENOMEM;
+		goto err_free_g29;
+	}
+
+	g29->udev = udev;
+	g29->input = input;
+
+	g29->endpoint = usb_endpoint_num(ep);
+	g29->maxp = usb_endpoint_maxp(ep);
+	g29->interval = ep->bInterval;
+	memset(&g29->last, 0, sizeof(g29->last));
+
+	timer_setup(&g29->steer_timer, g29_steer_timer_fn, 0);
+
+	if ((g29->buf = usb_alloc_coherent(udev, g29->maxp, GFP_KERNEL, &g29->buf_dma)) == NULL) {
+		ret = -ENOMEM;
+		goto err_free_input;
+	}
+
+	if ((g29->urb = usb_alloc_urb(0, GFP_KERNEL)) == NULL) {
+		ret = -ENOMEM;
+		goto err_free_buf;
+	}
+
+	if (udev->manufacturer)
+		strscpy(g29->name, udev->manufacturer, sizeof(g29->name));
+	if (udev->product) {
+		if (udev->manufacturer)
+			strlcat(g29->name, " ", sizeof(g29->name));
+		strlcat(g29->name, udev->product, sizeof(g29->name));
+	}
+	if (!strlen(g29->name))
+		snprintf(g29->name, sizeof(g29->name),
+			 "Logitech G29 USB %04x:%04x",
+			 le16_to_cpu(udev->descriptor.idVendor),
+			 le16_to_cpu(udev->descriptor.idProduct));
+
+	usb_make_path(udev, g29->phys, sizeof(g29->phys));
+	strlcat(g29->phys, "/input0", sizeof(g29->phys));
+
+	input->name = g29->name;
+	input->phys = g29->phys;
+	usb_to_input_id(udev, &input->id);
+	input->dev.parent = &intf->dev;
+
+	__set_bit(EV_KEY, input->evbit);
+
+	/* Advertise only the keys we emit in media mode. */
+	input_set_capability(input, EV_KEY, KEY_VOLUMEUP);
+	input_set_capability(input, EV_KEY, KEY_VOLUMEDOWN);
+	input_set_capability(input, EV_KEY, KEY_PLAYPAUSE);
+	input_set_capability(input, EV_KEY, KEY_NEXTSONG);
+	input_set_capability(input, EV_KEY, KEY_PREVIOUSSONG);
+
+	input_set_capability(input, EV_KEY, KEY_W);
+	input_set_capability(input, EV_KEY, KEY_A);
+	input_set_capability(input, EV_KEY, KEY_S);
+	input_set_capability(input, EV_KEY, KEY_D);
+
+	input_set_drvdata(input, g29);
+	input->open = g29_input_open;
+	input->close = g29_input_close;
+
+	usb_fill_int_urb(g29->urb, udev, usb_rcvintpipe(udev, ep->bEndpointAddress),
+			 g29->buf, g29->maxp,
+			 g29_urb_complete, g29, ep->bInterval);
+	g29->urb->transfer_dma = g29->buf_dma;
+	g29->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+	if ((ret = input_register_device(input)) != 0) {
+		goto err_free_urb;
+	}
+
+	usb_set_intfdata(intf, g29);
+
+	dev_info(&intf->dev,
+		 "G29 media driver bound (ep=%02x interval=%u)\n",
+		 ep->bEndpointAddress, ep->bInterval);
+
+	return 0;
+
+err_free_urb:
+	usb_free_urb(g29->urb);
+err_free_buf:
+	usb_free_coherent(udev, g29->maxp, g29->buf, g29->buf_dma);
+err_free_input:
+	input_free_device(input);
+err_free_g29:
+	kfree(g29);
+	return ret;
+}
+
+static void g29_disconnect(struct usb_interface *intf) {
+	struct g29_dev *g29 = usb_get_intfdata(intf);
+	usb_set_intfdata(intf, NULL);
+	if (!g29) return;
+	usb_kill_urb(g29->urb);
+	input_unregister_device(g29->input);
+	usb_free_urb(g29->urb);
+	usb_free_coherent(interface_to_usbdev(intf), g29->maxp, g29->buf, g29->buf_dma);
+	kfree(g29);
+	dev_info(&intf->dev, "G29 driver disconnected\n");
+}
+
+static const struct usb_device_id g29_id_table[] = {
+	{ USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G29) },
+	{ USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G29_ALT) },
+	{ }
+};
+MODULE_DEVICE_TABLE(usb, g29_id_table);
+
+static struct usb_driver g29_driver = {
+	.name = "g29_usb",
+	.id_table = g29_id_table,
+	.probe = g29_probe,
+	.disconnect = g29_disconnect,
+};
+
+module_usb_driver(g29_driver);

usb_driver_manager.py

@@ -6,6 +6,11 @@ and binding USB devices to new drivers.
 
 Note: USB drivers typically bind to interfaces, not devices. This script
 handles both device-level and interface-level driver binding.
+
+Wheel-friendly improvements:
+  - Finds kernel modules (*.ko) recursively under provided directories (e.g. ./build).
+  - Lets the user select which USB interface(s) to unbind/bind.
+    Default selection: all HID interfaces (bInterfaceClass==03).
 """
 
 import os
@@ -74,7 +79,7 @@ def get_usb_devices():
         result = subprocess.run(['lsusb'], capture_output=True, text=True)
         for line in result.stdout.splitlines():
             # Format: Bus 001 Device 005: ID 046d:c52b Logitech, Inc. Unifying Receiver
-            match = re.match(r'Bus (\d+) Device (\d+): ID ([0-9a-f]{4}):([0-9a-f]{4})\s+(.*)', line)
+            match = re.match(r'Bus (\d+) Device (\d+): ID ([0-9a-f]{4}):([0-9a-f]{4})\s+(.*)', line, re.IGNORECASE)
             if match:
                 bus, dev, vendor, product, name = match.groups()
                 key = f"{int(bus)}-{int(dev)}"
@@ -93,7 +98,7 @@ def get_usb_devices():
 
         # Only process actual device entries (format: busnum-devnum or busnum-port.port...)
         device_name = device_path.name
-        if not re.match(r'\d+-[\d.]+', device_name):
+        if not re.match(r'\d+-[\d.]+$', device_name):
             continue
 
         # Skip root hubs
@@ -116,21 +121,9 @@ def get_usb_devices():
             if driver_link.exists() and driver_link.is_symlink():
                 driver = driver_link.resolve().name
 
-            # Try to get better name from lsusb
-            lsusb_key = f"{int(busnum)}-{int(devnum)}"
-            if lsusb_key in lsusb_output:
-                product = lsusb_output[lsusb_key]['name']
-
-            # Check if it's an input device by looking at device class or interfaces
-            is_input = False
-            device_class = (device_path / "bDeviceClass").read_text().strip() if (device_path / "bDeviceClass").exists() else "00"
-
-            # Class 03 is HID (Human Interface Device)
-            if device_class == "03":
-                is_input = True
-
             # Check interfaces for HID class and collect interface information
             interfaces = []
+            is_input = False
             for interface_path in device_path.glob("*:*.*"):
                 if not interface_path.is_dir():
                     continue
@@ -160,6 +153,12 @@ def get_usb_devices():
                 except Exception:
                     continue
 
+            # Improve product string from lsusb when possible (safe conversion)
+            if busnum.isdigit() and devnum.isdigit():
+                lsusb_key = f"{int(busnum)}-{int(devnum)}"
+                if lsusb_key in lsusb_output:
+                    product = lsusb_output[lsusb_key]['name']
+
             devices.append({
                 'path': str(device_path),
                 'name': device_name,
@@ -172,7 +171,7 @@ def get_usb_devices():
                 'driver': driver,
                 'is_input': is_input,
                 'interfaces': interfaces,
-                'display_name': f"{manufacturer} {product}"
+                'display_name': f"{manufacturer} {product}".strip()
             })
 
         except Exception as e:
@@ -217,42 +216,45 @@ def get_kernel_modules(directories=None):
     modules = []
     seen_modules = set()  # Track module names to avoid duplicates
 
-    # Search for .ko files in each specified directory
+    # Search for .ko files recursively in each specified directory
     for directory in directories:
         if not os.path.exists(directory):
             print_warning(f"Directory not found: {directory}")
             continue
 
-        for ko_file in glob.glob(os.path.join(directory, "*.ko")):
+        for root, dirs, files in os.walk(directory):
-            module_name = os.path.basename(ko_file)
+            for filename in files:
-            module_path = os.path.abspath(ko_file)
+                if not filename.endswith('.ko'):
+                    continue
 
-            # Skip duplicates (same module name already found)
+                module_name = filename
-            if module_name in seen_modules:
+                module_path = os.path.abspath(os.path.join(root, filename))
-                continue
-            seen_modules.add(module_name)
 
-            # Get module info if possible
+                # Skip duplicates (same module name already found)
-            try:
+                if module_name in seen_modules:
-                result = subprocess.run(['modinfo', module_path],
+                    continue
-                                    capture_output=True, text=True)
+                seen_modules.add(module_name)
-                description = "No description"
-                for line in result.stdout.splitlines():
-                    if line.startswith("description:"):
-                        description = line.split(":", 1)[1].strip()
-                        break
 
-                modules.append({
+                # Get module info if possible
-                    'name': module_name,
+                try:
-                    'path': module_path,
+                    result = subprocess.run(['modinfo', module_path], capture_output=True, text=True)
-                    'description': description
+                    description = "No description"
-                })
+                    for line in result.stdout.splitlines():
-            except Exception:
+                        if line.startswith("description:"):
-                modules.append({
+                            description = line.split(":", 1)[1].strip()
-                    'name': module_name,
+                            break
-                    'path': module_path,
+
-                    'description': "No description available"
+                    modules.append({
-                })
+                        'name': module_name,
+                        'path': module_path,
+                        'description': description
+                    })
+                except Exception:
+                    modules.append({
+                        'name': module_name,
+                        'path': module_path,
+                        'description': "No description available"
+                    })
 
     return modules
 
@@ -295,6 +297,55 @@ def get_user_choice(prompt, max_choice):
             return None
 
 
+def get_interface_selection(device):
+    """Select which interface(s) to unbind/bind.
+
+    Default (Enter): all HID interfaces (class 03).
+    'a' selects all interfaces.
+    Comma-separated list selects specific interfaces.
+    """
+    if not device.get('interfaces'):
+        return []
+
+    print_header("Interfaces")
+    for idx, iface in enumerate(device['interfaces'], 1):
+        driver_color = Colors.GREEN if iface['driver'] != "none" else Colors.YELLOW
+        print(f"  {idx:>2}. {iface['name']}: class={iface['class']} subclass={iface['subclass']} protocol={iface['protocol']} driver={driver_color}{iface['driver']}{Colors.END}")
+
+    print("\nSelect interfaces to bind:")
+    print("  [Enter]  AUTO: all HID interfaces (class 03)")
+    print("  a        ALL interfaces")
+    print("  1,3      Comma-separated list")
+
+    raw = input("Selection: ").strip().lower()
+    if raw == "":
+        picked = [i for i in device['interfaces'] if i['class'] == "03"]
+        if not picked:
+            print_warning("No HID interfaces found; selecting ALL interfaces.")
+            picked = list(device['interfaces'])
+        return picked
+
+    if raw == "a":
+        return list(device['interfaces'])
+
+    picked = []
+    parts = [p.strip() for p in raw.split(',') if p.strip()]
+    for p in parts:
+        try:
+            i = int(p)
+            if 1 <= i <= len(device['interfaces']):
+                picked.append(device['interfaces'][i - 1])
+        except ValueError:
+            continue
+
+    if not picked:
+        print_warning("No valid interfaces selected; using AUTO (all HID interfaces).")
+        picked = [i for i in device['interfaces'] if i['class'] == "03"]
+        if not picked:
+            picked = list(device['interfaces'])
+    return picked
+
+
 def unbind_device(device, interface=None):
     """Unbind device interface from current driver"""
     # If specific interface provided, unbind that interface
@@ -355,8 +406,7 @@ def load_module(module):
     """Load kernel module"""
     try:
         print(f"Loading module {module['name']}...")
-        result = subprocess.run(['insmod', module['path']],
+        result = subprocess.run(['insmod', module['path']], capture_output=True, text=True)
-                              capture_output=True, text=True)
         if result.returncode == 0:
             print_success(f"Successfully loaded {module['name']}")
             return True
@@ -435,7 +485,7 @@ def bind_device(device, module, interface=None):
             print_error(f"Failed to bind interface: {e}")
             return False
 
-    # Otherwise try to bind all HID mouse interfaces (class 03, subclass 01, protocol 02)
+    # Default behavior (kept for backwards compatibility): try boot mouse, then device.
     target_interfaces = []
     for iface in device.get('interfaces', []):
         # Look for HID Boot Mouse interfaces
@@ -482,13 +532,35 @@ def bind_device(device, module, interface=None):
     return success
 
 
+def bind_interface_to_driver(interface_name, driver_name):
+    """Bind a specific USB interface back to a given driver name (sysfs)."""
+    driver_path = Path(f"/sys/bus/usb/drivers/{driver_name}")
+    bind_path = driver_path / "bind"
+
+    if not driver_path.exists():
+        print_warning(f"Cannot restore: driver path not found: {driver_path}")
+        return False
+
+    if not bind_path.exists():
+        print_warning(f"Cannot restore: bind path not found: {bind_path}")
+        return False
+
+    try:
+        print(f"Restoring interface {interface_name} to driver {driver_name}...")
+        bind_path.write_text(interface_name)
+        print_success(f"Restored {interface_name} to {driver_name}")
+        return True
+    except Exception as e:
+        print_warning(f"Failed to restore interface {interface_name} to {driver_name}: {e}")
+        return False
+
+
 def unload_module(module):
     """Unload kernel module"""
     driver_name = get_module_driver_name(module)
     try:
         print(f"Unloading module {driver_name}...")
-        result = subprocess.run(['rmmod', driver_name],
+        result = subprocess.run(['rmmod', driver_name], capture_output=True, text=True)
-                              capture_output=True, text=True)
         if result.returncode == 0:
             print_success(f"Successfully unloaded {driver_name}")
             return True
@@ -562,12 +634,16 @@ def main():
     print(f"  Device: {selected_device['name']}")
     print(f"  Current driver: {selected_device['driver']}")
 
-    # Show interfaces
+    # Step 2b: Select interfaces
-    if selected_device.get('interfaces'):
+    selected_interfaces = get_interface_selection(selected_device)
-        print(f"\n  Interfaces:")
+    if not selected_interfaces:
-        for iface in selected_device['interfaces']:
+        print_warning("No interfaces available/selected; cannot bind.")
-            driver_color = Colors.GREEN if iface['driver'] != "none" else Colors.YELLOW
+        sys.exit(1)
-            print(f"    {iface['name']}: class={iface['class']} subclass={iface['subclass']} protocol={iface['protocol']} driver={driver_color}{iface['driver']}{Colors.END}")
+
+    # Remember original per-interface drivers for restore attempts
+    original_interface_drivers = {}
+    for iface in selected_interfaces:
+        original_interface_drivers[iface['name']] = iface.get('driver', 'none')
 
     # Step 3: List available kernel modules
     if len(args.directories) > 1 or args.directories[0] != '.':
@@ -594,17 +670,14 @@ def main():
 
     # Step 5: Confirm operation
     print(f"\n{Colors.YELLOW}This will:{Colors.END}")
-    if selected_device.get('interfaces'):
+    print(f"  1. Unbind {len(selected_interfaces)} interface(s) from current driver(s)")
-        print(f"  1. Unbind interface(s) from current driver(s)")
-    else:
-        print(f"  1. Unbind {selected_device['name']} from {selected_device['driver']}")
     if module_already_loaded:
         print(f"  2. Unload existing module {selected_module['name']}")
         print(f"  3. Load module {selected_module['name']} (fresh version)")
-        print(f"  4. Bind interface(s) to the new driver")
+        print(f"  4. Bind selected interface(s) to the new driver")
     else:
         print(f"  2. Load module {selected_module['name']}")
-        print(f"  3. Bind interface(s) to the new driver")
+        print(f"  3. Bind selected interface(s) to the new driver")
 
     confirm = input(f"\n{Colors.BOLD}Proceed? (yes/no): {Colors.END}").strip().lower()
     if confirm not in ['yes', 'y']:
@@ -614,10 +687,11 @@ def main():
     # Step 6: Perform operations
     print_header("\nExecuting operations...")
 
-    # Unbind from current driver
+    # Unbind selected interfaces from current drivers
-    if not unbind_device(selected_device):
+    for iface in selected_interfaces:
-        print_error("Failed to unbind device. Aborting.")
+        if not unbind_device(selected_device, iface):
-        sys.exit(1)
+            print_error("Failed to unbind interface. Aborting.")
+            sys.exit(1)
 
     # Unload module if already loaded
     if module_already_loaded:
@@ -631,24 +705,36 @@ def main():
     # Load new module
     if not load_module(selected_module):
         print_error("Failed to load module. Attempting to restore...")
-        # Try to rebind to original driver if available
+        # Try to rebind each selected interface to its original driver
-        if selected_device['driver'] != "none":
+        for iface in selected_interfaces:
-            bind_device(selected_device, {'name': selected_device['driver'] + '.ko'})
+            orig = original_interface_drivers.get(iface['name'], 'none')
+            if orig != 'none':
+                bind_interface_to_driver(iface['name'], orig)
         sys.exit(1)
 
     # Give kernel time to auto-probe and bind
     print("Waiting for kernel to probe interfaces...")
     time.sleep(0.5)
 
-    # Bind to new driver
+    # Bind selected interfaces to new driver
-    if not bind_device(selected_device, selected_module):
+    bound_any = False
-        print_error("Failed to bind device to new driver.")
+    for iface in selected_interfaces:
-        print_warning("Device may be unbound. You might need to reconnect it or bind manually.")
+        if bind_device(selected_device, selected_module, iface):
+            bound_any = True
+        else:
+            # Restore interfaces that failed to bind to the new driver
+            orig = original_interface_drivers.get(iface['name'], 'none')
+            if orig != 'none':
+                bind_interface_to_driver(iface['name'], orig)
+
+    if not bound_any:
+        print_error("Failed to bind any interface to the new driver.")
+        print_warning("All selected interfaces were restored where possible. You might need to reconnect the device.")
         sys.exit(1)
 
     # Success
     print_header("\nOperation completed successfully!")
-    print(f"{Colors.GREEN}Device {selected_device['name']} is now using the new driver{Colors.END}")
+    print(f"{Colors.GREEN}Device {selected_device['name']} interface(s) are now using the new driver{Colors.END}")
 
     # Offer to show new device status
     print("\nVerifying device status...")

wasd-emulator/Makefile

@@ -0,0 +1,25 @@
+
+.PHONY: all
+
+obj-m += wasd.o
+KVER := $(shell uname -r)
+KDIR ?= $(firstword $(wildcard /lib/modules/$(KVER)/build) $(wildcard /usr/lib/modules/$(KVER)/build))
+PWD := $(shell pwd)
+OUT := $(PWD)/out
+
+all:
+	@if [ -z "$(KDIR)" ]; then \
+		echo "ERROR: kernel build dir not found for $(KVER). Install kernel headers (e.g. linux-headers)"; \
+		exit 2; \
+	fi
+	mkdir -p $(OUT)
+	$(MAKE) -C $(KDIR) M=$(PWD) modules
+	-mv -f -- *.ko *.mod.c *.o .*.o *.mod modules.order .*.cmd *.symvers $(OUT)
+
+clean:
+	@if [ -z "$(KDIR)" ]; then \
+		echo "ERROR: kernel build dir not found for $(KVER)."; \
+		exit 2; \
+	fi
+	$(MAKE) -C $(KDIR) M=$(PWD) clean
+	rm -rf $(OUT) *.cmd *.order *.mod *.o

wasd-emulator/wasd.c

@@ -0,0 +1,223 @@
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/input.h>
+#include <linux/input.h>
+#include <linux/slab.h>
+
+#define DRV_NAME "usb_steeringwheel_wasd"
+
+struct wheel_evt {
+    uint32_t buttons_be;
+    uint16_t rot_be;
+    uint8_t gas;
+    uint8_t brk;
+    uint8_t clt;
+    uint8_t gr_x;
+    uint8_t gr_y;
+    uint8_t gr_z;
+};
+
+struct wheel {
+    struct usb_device *udev;
+    struct usb_interface *intf;
+    struct input_dev *input;
+
+    struct urb *irq_urb;
+    struct wheel_evt *irq_data;
+    dma_addr_t irq_dma;
+    int irq_len;
+    int irq_interval;
+    int irq_ep;
+
+    char phys[64];
+    atomic_t opened;
+};
+
+static int drv_open(struct input_dev *dev) {
+    struct wheel *w = input_get_drvdata(dev);
+    if (!w) return -ENODEV;
+    atomic_set(&w->opened, 1);
+    int ret;
+    if ((ret = usb_submit_urb(w->irq_urb, GFP_KERNEL))) {
+        atomic_set(&w->opened, 0);
+        return ret;
+    }
+    return 0;
+}
+
+static void drv_irq(struct urb *urb) {
+    // called every 2ms?
+    struct wheel *w = urb->context;
+    if (!w || !atomic_read(&w->opened))
+        return;
+
+    const int status = urb->status;
+    if (status) {
+        if (status == -ENOENT || status == -ECONNRESET || status == -ESHUTDOWN)
+            return;
+        dev_dbg(&w->intf->dev, "irq urb status %d\n", status);
+        goto resubmit;
+    }
+
+    const struct wheel_evt *data = w->irq_data;
+    const int rot = be16_to_cpu(data->buttons_be);
+    // TODO set keys according to ratio
+    input_report_key(w->input, KEY_W, data->gas <= 0x80);
+    input_report_key(w->input, KEY_S, data->brk <= 0x80);
+    input_report_key(w->input, KEY_A, rot <= 0x6000);
+    input_report_key(w->input, KEY_D, rot >= 0xA000);
+    input_sync(w->input);
+
+resubmit:
+    usb_submit_urb(w->irq_urb, GFP_ATOMIC);
+}
+
+static void drv_close(struct input_dev *dev) {
+    struct wheel *w = input_get_drvdata(dev);
+    if (!w) return;
+    atomic_set(&w->opened, 0);
+    usb_kill_urb(w->irq_urb);
+}
+
+static int drv_probe(struct usb_interface *intf, const struct usb_device_id *id) {
+    struct usb_device *udev = interface_to_usbdev(intf);
+    int ret;
+
+    // Logitech G29
+    //if (le16_to_cpu(udev->descriptor.idVendor) != 0x046d || le16_to_cpu(udev->descriptor.idProduct) != 0xc24f)
+    //    return -ENODEV;
+
+    struct usb_endpoint_descriptor *ep = NULL;
+    const struct usb_host_interface *alts = intf->cur_altsetting;
+    for (int i = 0; i < alts->desc.bNumEndpoints; i++) {
+        struct usb_endpoint_descriptor *d = &alts->endpoint[i].desc;
+        if (usb_endpoint_is_int_in(d)) {
+            ep = d;
+            break;
+        }
+    }
+    if (!ep) return -ENODEV;
+
+    struct wheel *w;
+    if ((w = kzalloc(sizeof(*w), GFP_KERNEL)) == NULL)
+        return -ENOMEM;
+
+    w->udev = usb_get_dev(udev);
+    w->intf = intf;
+    atomic_set(&w->opened, 0);
+
+    w->irq_ep = usb_endpoint_num(ep);
+    w->irq_len = usb_endpoint_maxp(ep);
+    w->irq_interval = ep->bInterval;
+
+    if ((w->irq_urb = usb_alloc_urb(0, GFP_KERNEL)) == NULL) {
+        ret = -ENOMEM;
+        goto err_free;
+    }
+
+    if ((w->irq_data = usb_alloc_coherent(udev, w->irq_len, GFP_KERNEL, &w->irq_dma)) == NULL) {
+        ret = -ENOMEM;
+        goto err_free_urb;
+    }
+
+    if ((w->input = input_allocate_device()) == NULL) {
+        ret = -ENOMEM;
+        goto err_free_buf;
+    }
+
+    usb_make_path(udev, w->phys, sizeof(w->phys));
+    strlcat(w->phys, "/input0", sizeof(w->phys));
+
+    w->input->name = "USB Boot Mouse (example driver)";
+    w->input->phys = w->phys;
+    usb_to_input_id(udev, &w->input->id);
+    w->input->dev.parent = &intf->dev;
+
+    w->input->open = drv_open;
+    w->input->close = drv_close;
+
+    input_set_drvdata(w->input, w);
+
+    usb_fill_int_urb(
+        w->irq_urb,
+        udev,
+        usb_rcvintpipe(udev, ep->bEndpointAddress),
+        w->irq_data,
+        w->irq_len,
+        drv_irq,
+        w,
+        w->irq_interval);
+
+    w->irq_urb->transfer_dma = w->irq_dma;
+    w->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
+
+    usb_set_intfdata(intf, w);
+
+    if ((ret = input_register_device(w->input)) != 0)
+        goto err_clear_intfdata;
+
+    dev_info(&intf->dev,
+        "bound to %04x:%04x, int-in ep 0x%02x maxp %u interval %u\n",
+        le16_to_cpu(udev->descriptor.idVendor),
+        le16_to_cpu(udev->descriptor.idProduct),
+        ep->bEndpointAddress,
+        w->irq_len,
+        w->irq_interval);
+
+    return 0;
+
+err_clear_intfdata:
+    usb_set_intfdata(intf, NULL);
+    input_free_device(w->input);
+    w->input = NULL;
+err_free_buf:
+    usb_free_coherent(udev, w->irq_len, w->irq_data, w->irq_dma);
+err_free_urb:
+    usb_free_urb(w->irq_urb);
+err_free:
+    usb_put_dev(w->udev);
+    kfree(w);
+    return ret;
+}
+
+static void drv_disconnect(struct usb_interface *intf) {
+    struct wheel *w = usb_get_intfdata(intf);
+    usb_set_intfdata(intf, NULL);
+    if (!w) return;
+
+    if (w->input) {
+        input_unregister_device(w->input);
+        w->input = NULL;
+    }
+
+    usb_kill_urb(w->irq_urb);
+    usb_free_coherent(w->udev, w->irq_len, w->irq_data, w->irq_dma);
+    usb_free_urb(w->irq_urb);
+    usb_put_dev(w->udev);
+    kfree(w);
+
+    dev_info(&intf->dev, "disconnected\n");
+}
+
+static const struct usb_device_id drv_id_table[] = {
+    { USB_DEVICE_INTERFACE_NUMBER(0x046d, 0xc24f, 0) },
+    { USB_INTERFACE_INFO(3, 1, 1) },
+    {}
+};
+MODULE_DEVICE_TABLE(usb, drv_id_table);
+
+static struct usb_driver drv = {
+    .name = DRV_NAME,
+    .probe = drv_probe,
+    .disconnect = drv_disconnect,
+    .id_table = drv_id_table,
+};
+
+module_usb_driver(drv);
+
+MODULE_AUTHOR("Lorenz Stechauner");
+MODULE_DESCRIPTION("Steering wheel WASD emulator");
+MODULE_LICENSE("GPL");