lorenz.stechauner/Device-Driver
1
0
Fork 0
Code Pull Requests Activity

Compare commits

base: lorenz.stechauner:6d5c46782965122bbe2dc5c29e66d6fc0d25791b
Branches Tags
lorenz.stechauner:main lorenz.stechauner:elso-phase-accumulator-approach lorenz.stechauner:tom lorenz.stechauner:felix
..
compare: lorenz.stechauner:0e6a55374040fb81ec5f0458ea3601ed53ed8c73
Branches Tags
lorenz.stechauner:elso-phase-accumulator-approach lorenz.stechauner:main lorenz.stechauner:tom lorenz.stechauner:felix

3 Commits
6d5c467829 ... 0e6a553740

Author SHA1 Message Date
Felix Peterka
0e6a553740 First implementation of Media Control 2026-01-17 11:44:42 +01:00
Thomas Hilscher
3cc6115694 Fixed mouse driver and moved to seperate folder 2026-01-17 11:44:05 +01:00
Thomas Hilscher
8ab4ca7533 Added first tries 2026-01-17 11:42:49 +01:00
6 changed files with 1007 additions and 475 deletions
Expand all files Collapse all files

84
.gitignore vendored
View File

@@ -1,42 +1,42 @@
# IDE and Editor # IDE and Editor
.vscode/ .vscode/
.idea/ .idea/
*.swp *.swp
*.swo *.swo
*~ *~
.DS_Store .DS_Store
# Dependencies # Dependencies
node_modules/ node_modules/
__pycache__/ __pycache__/
*.pyc *.pyc
*.pyo *.pyo
*.egg-info/ *.egg-info/
.venv/ .venv/
venv/ venv/
# Build outputs # Build outputs
dist/ dist/
build/ build/
*.o *.o
*.a *.a
*.so *.so
*.ko *.ko
*.mod *.mod
*.mod.c *.mod.c
*.cmd *.cmd
.*.cmd .*.cmd
Module.symvers Module.symvers
modules.order modules.order
# Logs # Logs
*.log *.log
npm-debug.log* npm-debug.log*
# Environment variables # Environment variables
.env .env
.env.local .env.local
# OS files # OS files
Thumbs.db Thumbs.db
.DS_Store .DS_Store

63
README.md
View File

@@ -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
```

28
g29_media_usb/Makefile Normal file
View File

@@ -0,0 +1,28 @@
obj-m += g29_media_usb.o
PWD := $(CURDIR)
.PHONY: all clean install uninstall
all:
$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
mkdir -p build
mv -f *.ko build/ 2>/dev/null || true
clean:
$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
rm -rf build
install:
$(MAKE) -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules_install
depmod -a
uninstall:
@modpath=$$(modinfo -n g29_media_usb 2>/dev/null); \
if [ -z "$$modpath" ]; then \
echo "Module g29_media_usb not found via modinfo (not installed?)"; \
exit 1; \
fi; \
echo "Removing $$modpath"; \
rm -f "$$modpath"; \
depmod -a

361
g29_media_usb/g29_media_usb.c Normal file
View File

@@ -0,0 +1,361 @@
// 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 <asm/unaligned.h>
MODULE_AUTHOR("LLP group 32");
MODULE_DESCRIPTION("Logitech G29 -> Media keys (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_REPORT_LEN 12
/*
* Button masks
*/
#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;
u16 rot;
u8 gas;
u8 brk;
u8 clt;
u8 grx;
u8 gry;
u8 grz;
};
/*
* Mapping table entry
*/
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;
struct g29_state last;
};
/* Parsing */
static bool g29_parse_report(struct g29_state *out, const u8 *data, int len)
{
if (len < G29_REPORT_LEN)
return false;
/* bytes 0..3 buttons bitfield */
out->buttons = get_unaligned_le32(&data[0]);
/* bytes 4..5 rotation */
out->rot = get_unaligned_le16(&data[4]);
out->gas = data[6];
out->brk = data[7];
out->clt = data[8];
out->grx = data[9];
out->gry = data[10];
out->grz = data[11];
return true;
}
/* Mapping policy */
static void g29_pulse_key(struct input_dev *input, unsigned short keycode)
{
/* A pulse is a press+release within one report frame. */
input_report_key(input, keycode, 1);
input_report_key(input, keycode, 0);
}
static void g29_apply_media_mode(struct g29_dev *g29,
const struct g29_state *prev,
const struct g29_state *cur)
{
u32 pressed = cur->buttons & ~prev->buttons;
size_t i;
for (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)
g29_pulse_key(g29->input, e->keycode);
}
input_sync(g29->input);
}
static void g29_process_report(struct g29_dev *g29, const u8 *data, int len)
{
struct g29_state cur;
if (!g29_parse_report(&cur, data, len))
return;
switch (mode) {
case G29_MODE_MEDIA:
default:
g29_apply_media_mode(g29, &g29->last, &cur);
break;
}
g29->last = cur;
}
/* URB plumbing */
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;
return 0;
}
static void g29_input_close(struct input_dev *input)
{
struct g29_dev *g29 = input_get_drvdata(input);
usb_kill_urb(g29->urb);
}
/* USB driver binding */
static int g29_probe(struct usb_interface *intf, const struct usb_device_id *id)
{
struct usb_device *udev = interface_to_usbdev(intf);
struct usb_host_interface *alts = intf->cur_altsetting;
struct usb_endpoint_descriptor *ep = NULL;
struct g29_dev *g29;
struct input_dev *input;
int i, pipe, maxp, error;
/* Find an interrupt IN endpoint capable of carrying the 12-byte report. */
for (i = 0; i < alts->desc.bNumEndpoints; i++) {
struct usb_endpoint_descriptor *cand = &alts->endpoint[i].desc;
if (!usb_endpoint_is_int_in(cand))
continue;
pipe = usb_rcvintpipe(udev, cand->bEndpointAddress);
maxp = usb_maxpacket(udev, pipe);
if (maxp >= G29_REPORT_LEN) {
ep = cand;
break;
}
}
if (!ep)
return -ENODEV;
g29 = kzalloc(sizeof(*g29), GFP_KERNEL);
if (!g29)
return -ENOMEM;
input = input_allocate_device();
if (!input) {
error = -ENOMEM;
goto err_free_g29;
}
g29->udev = udev;
g29->input = input;
memset(&g29->last, 0, sizeof(g29->last));
/* Allocate a fixed-size report buffer (12 bytes). */
g29->buf = usb_alloc_coherent(udev, G29_REPORT_LEN, GFP_KERNEL, &g29->buf_dma);
if (!g29->buf) {
error = -ENOMEM;
goto err_free_input;
}
g29->urb = usb_alloc_urb(0, GFP_KERNEL);
if (!g29->urb) {
error = -ENOMEM;
goto err_free_buf;
}
/* Build a friendly input device name. */
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 Media %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_drvdata(input, g29);
input->open = g29_input_open;
input->close = g29_input_close;
pipe = usb_rcvintpipe(udev, ep->bEndpointAddress);
usb_fill_int_urb(g29->urb, udev, pipe,
g29->buf, G29_REPORT_LEN,
g29_urb_complete, g29, ep->bInterval);
g29->urb->transfer_dma = g29->buf_dma;
g29->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
error = input_register_device(input);
if (error)
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_REPORT_LEN, g29->buf, g29->buf_dma);
err_free_input:
input_free_device(input);
err_free_g29:
kfree(g29);
return error;
}
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_REPORT_LEN,
g29->buf, g29->buf_dma);
kfree(g29);
dev_info(&intf->dev, "G29 media 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_media_usb",
.probe = g29_probe,
.disconnect = g29_disconnect,
.id_table = g29_id_table,
};
module_usb_driver(g29_driver);

714
mouse/simple_usb_mouse.c
View File

@@ -1,357 +1,357 @@
// SPDX-License-Identifier: GPL-2.0 // SPDX-License-Identifier: GPL-2.0
/* /*
* Simple USB Mouse Driver * Simple USB Mouse Driver
* *
* A minimal USB HID Boot Protocol mouse driver for learning purposes. * A minimal USB HID Boot Protocol mouse driver for learning purposes.
* This driver can bind to any standard USB mouse that supports the * This driver can bind to any standard USB mouse that supports the
* HID Boot Protocol. * HID Boot Protocol.
*/ */
#include <linux/kernel.h> #include <linux/kernel.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/usb.h> #include <linux/usb.h>
#include <linux/usb/input.h> #include <linux/usb/input.h>
#include <linux/hid.h> #include <linux/hid.h>
#include <linux/input.h> #include <linux/input.h>
#define DRIVER_AUTHOR "Testor" #define DRIVER_AUTHOR "Testor"
#define DRIVER_DESC "Simple USB Mouse Driver" #define DRIVER_DESC "Simple USB Mouse Driver"
MODULE_AUTHOR(DRIVER_AUTHOR); MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC); MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
/* /*
* Driver context structure * Driver context structure
* This holds all the data we need for each connected mouse * This holds all the data we need for each connected mouse
*/ */
struct simple_usb_mouse { struct simple_usb_mouse {
char name[128]; /* Device name */ char name[128]; /* Device name */
char phys[64]; /* Physical path */ char phys[64]; /* Physical path */
struct usb_device *usbdev; /* USB device */ struct usb_device *usbdev; /* USB device */
struct input_dev *input_dev; /* Input device for reporting events */ struct input_dev *input_dev; /* Input device for reporting events */
struct urb *irq; /* URB for interrupt transfers */ struct urb *irq; /* URB for interrupt transfers */
unsigned char *data; /* Data buffer (8 bytes for mouse data) */ unsigned char *data; /* Data buffer (8 bytes for mouse data) */
dma_addr_t data_dma; /* DMA address for data buffer */ dma_addr_t data_dma; /* DMA address for data buffer */
}; };
/* /*
* IRQ handler - called when mouse sends data * IRQ handler - called when mouse sends data
* *
* Cooler Master MM710 format (8 bytes): * Cooler Master MM710 format (8 bytes):
* Byte 0: Button states * Byte 0: Button states
* Bit 0: Left button * Bit 0: Left button
* Bit 1: Right button * Bit 1: Right button
* Bit 2: Middle button * Bit 2: Middle button
* Bit 3: Side button * Bit 3: Side button
* Bit 4: Extra button * Bit 4: Extra button
* Bytes 1: (unused) * Bytes 1: (unused)
* Bytes 2-3: X movement (16-bit signed, little-endian) * Bytes 2-3: X movement (16-bit signed, little-endian)
* Bytes 4-5: Y movement (16-bit signed, little-endian) * Bytes 4-5: Y movement (16-bit signed, little-endian)
* Byte 6: Wheel movement (8-bit signed) * Byte 6: Wheel movement (8-bit signed)
* Byte 7: (unused) * Byte 7: (unused)
*/ */
static void simple_mouse_irq(struct urb *urb) static void simple_mouse_irq(struct urb *urb)
{ {
struct simple_usb_mouse *mouse = urb->context; struct simple_usb_mouse *mouse = urb->context;
unsigned char *data = mouse->data; unsigned char *data = mouse->data;
struct input_dev *dev = mouse->input_dev; struct input_dev *dev = mouse->input_dev;
int status; int status;
int16_t x_movement, y_movement; int16_t x_movement, y_movement;
/* Check URB status */ /* Check URB status */
switch (urb->status) { switch (urb->status) {
case 0: case 0:
/* Success - process the data */ /* Success - process the data */
break; break;
case -ECONNRESET: case -ECONNRESET:
case -ENOENT: case -ENOENT:
case -ESHUTDOWN: case -ESHUTDOWN:
/* Device disconnected or URB killed - don't resubmit */ /* Device disconnected or URB killed - don't resubmit */
pr_debug("simple_mouse: URB stopped (status %d)\n", urb->status); pr_debug("simple_mouse: URB stopped (status %d)\n", urb->status);
return; return;
default: default:
/* Transient error - we'll resubmit and try again */ /* Transient error - we'll resubmit and try again */
pr_debug("simple_mouse: URB error (status %d)\n", urb->status); pr_debug("simple_mouse: URB error (status %d)\n", urb->status);
goto resubmit; goto resubmit;
} }
/* Debug: Print raw data bytes */ /* Debug: Print raw data bytes */
/* pr_info("simple_mouse: RAW DATA: [0]=%02x [1]=%02x [2]=%02x [3]=%02x [4]=%02x [5]=%02x [6]=%02x [7]=%02x\n", /* pr_info("simple_mouse: RAW DATA: [0]=%02x [1]=%02x [2]=%02x [3]=%02x [4]=%02x [5]=%02x [6]=%02x [7]=%02x\n",
data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); */ data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]); */
/* Report button states */ /* Report button states */
input_report_key(dev, BTN_LEFT, data[0] & 0x01); input_report_key(dev, BTN_LEFT, data[0] & 0x01);
input_report_key(dev, BTN_RIGHT, data[0] & 0x02); input_report_key(dev, BTN_RIGHT, data[0] & 0x02);
input_report_key(dev, BTN_MIDDLE, data[0] & 0x04); input_report_key(dev, BTN_MIDDLE, data[0] & 0x04);
input_report_key(dev, BTN_SIDE, data[0] & 0x08); input_report_key(dev, BTN_SIDE, data[0] & 0x08);
input_report_key(dev, BTN_EXTRA, data[0] & 0x10); input_report_key(dev, BTN_EXTRA, data[0] & 0x10);
/* Combine bytes for 16-bit movement (little-endian) */ /* Combine bytes for 16-bit movement (little-endian) */
x_movement = (int16_t)(data[2] | (data[3] << 8)); x_movement = (int16_t)(data[2] | (data[3] << 8));
y_movement = (int16_t)(data[4] | (data[5] << 8)); y_movement = (int16_t)(data[4] | (data[5] << 8));
/* Report movement (relative coordinates) */ /* Report movement (relative coordinates) */
input_report_rel(dev, REL_X, x_movement); input_report_rel(dev, REL_X, x_movement);
input_report_rel(dev, REL_Y, y_movement); input_report_rel(dev, REL_Y, y_movement);
input_report_rel(dev, REL_WHEEL, (signed char) data[6]); input_report_rel(dev, REL_WHEEL, (signed char) data[6]);
/* Sync - tell input subsystem we're done with this event */ /* Sync - tell input subsystem we're done with this event */
input_sync(dev); input_sync(dev);
resubmit: resubmit:
/* Resubmit URB to continue receiving data */ /* Resubmit URB to continue receiving data */
status = usb_submit_urb(urb, GFP_ATOMIC); status = usb_submit_urb(urb, GFP_ATOMIC);
if (status) { if (status) {
dev_err(&mouse->usbdev->dev, dev_err(&mouse->usbdev->dev,
"Failed to resubmit URB: %d\n", status); "Failed to resubmit URB: %d\n", status);
} }
} }
/* /*
* Called when device is opened (e.g., when an application reads from it) * Called when device is opened (e.g., when an application reads from it)
* We start the URB here to save resources when mouse isn't being used * We start the URB here to save resources when mouse isn't being used
*/ */
static int simple_mouse_open(struct input_dev *dev) static int simple_mouse_open(struct input_dev *dev)
{ {
struct simple_usb_mouse *mouse = input_get_drvdata(dev); struct simple_usb_mouse *mouse = input_get_drvdata(dev);
pr_info("simple_mouse: Device opened\n"); pr_info("simple_mouse: Device opened\n");
mouse->irq->dev = mouse->usbdev; mouse->irq->dev = mouse->usbdev;
if (usb_submit_urb(mouse->irq, GFP_KERNEL)) { if (usb_submit_urb(mouse->irq, GFP_KERNEL)) {
pr_err("simple_mouse: Failed to submit URB on open\n"); pr_err("simple_mouse: Failed to submit URB on open\n");
return -EIO; return -EIO;
} }
return 0; return 0;
} }
/* /*
* Called when device is closed * Called when device is closed
* Stop the URB to save resources * Stop the URB to save resources
*/ */
static void simple_mouse_close(struct input_dev *dev) static void simple_mouse_close(struct input_dev *dev)
{ {
struct simple_usb_mouse *mouse = input_get_drvdata(dev); struct simple_usb_mouse *mouse = input_get_drvdata(dev);
pr_info("simple_mouse: Device closed\n"); pr_info("simple_mouse: Device closed\n");
usb_kill_urb(mouse->irq); usb_kill_urb(mouse->irq);
} }
/* /*
* Probe function - called when a matching USB device is connected * Probe function - called when a matching USB device is connected
*/ */
static int simple_mouse_probe(struct usb_interface *intf, static int simple_mouse_probe(struct usb_interface *intf,
const struct usb_device_id *id) const struct usb_device_id *id)
{ {
struct usb_device *usbdev = interface_to_usbdev(intf); struct usb_device *usbdev = interface_to_usbdev(intf);
struct usb_host_interface *interface; struct usb_host_interface *interface;
struct usb_endpoint_descriptor *endpoint; struct usb_endpoint_descriptor *endpoint;
struct simple_usb_mouse *mouse; struct simple_usb_mouse *mouse;
struct input_dev *input_dev; struct input_dev *input_dev;
int pipe, maxp; int pipe, maxp;
int error = -ENOMEM; int error = -ENOMEM;
pr_info("simple_mouse: Probing device %04x:%04x\n", pr_info("simple_mouse: Probing device %04x:%04x\n",
le16_to_cpu(usbdev->descriptor.idVendor), le16_to_cpu(usbdev->descriptor.idVendor),
le16_to_cpu(usbdev->descriptor. idProduct)); le16_to_cpu(usbdev->descriptor. idProduct));
interface = intf->cur_altsetting; interface = intf->cur_altsetting;
/* Validate interface has exactly 1 endpoint */ /* Validate interface has exactly 1 endpoint */
if (interface->desc.bNumEndpoints != 1) { if (interface->desc.bNumEndpoints != 1) {
pr_err("simple_mouse: Interface has %d endpoints (expected 1)\n", pr_err("simple_mouse: Interface has %d endpoints (expected 1)\n",
interface->desc.bNumEndpoints); interface->desc.bNumEndpoints);
return -ENODEV; return -ENODEV;
} }
endpoint = &interface->endpoint[0]. desc; endpoint = &interface->endpoint[0]. desc;
/* Ensure it's an interrupt IN endpoint */ /* Ensure it's an interrupt IN endpoint */
if (! usb_endpoint_is_int_in(endpoint)) { if (! usb_endpoint_is_int_in(endpoint)) {
pr_err("simple_mouse: Endpoint is not interrupt IN\n"); pr_err("simple_mouse: Endpoint is not interrupt IN\n");
return -ENODEV; return -ENODEV;
} }
/* Calculate pipe and max packet size */ /* Calculate pipe and max packet size */
pipe = usb_rcvintpipe(usbdev, endpoint->bEndpointAddress); pipe = usb_rcvintpipe(usbdev, endpoint->bEndpointAddress);
maxp = usb_maxpacket(usbdev, pipe); maxp = usb_maxpacket(usbdev, pipe);
/* Allocate our context structure */ /* Allocate our context structure */
mouse = kzalloc(sizeof(struct simple_usb_mouse), GFP_KERNEL); mouse = kzalloc(sizeof(struct simple_usb_mouse), GFP_KERNEL);
if (!mouse) if (!mouse)
return -ENOMEM; return -ENOMEM;
/* Allocate input device */ /* Allocate input device */
input_dev = input_allocate_device(); input_dev = input_allocate_device();
if (!input_dev) { if (!input_dev) {
pr_err("simple_mouse: Failed to allocate input device\n"); pr_err("simple_mouse: Failed to allocate input device\n");
goto fail_input_alloc; goto fail_input_alloc;
} }
/* Allocate DMA-coherent buffer for USB data */ /* Allocate DMA-coherent buffer for USB data */
mouse->data = usb_alloc_coherent(usbdev, 8, GFP_KERNEL, mouse->data = usb_alloc_coherent(usbdev, 8, GFP_KERNEL,
&mouse->data_dma); &mouse->data_dma);
if (!mouse->data) { if (!mouse->data) {
pr_err("simple_mouse: Failed to allocate DMA buffer\n"); pr_err("simple_mouse: Failed to allocate DMA buffer\n");
goto fail_dma_alloc; goto fail_dma_alloc;
} }
/* Allocate URB */ /* Allocate URB */
mouse->irq = usb_alloc_urb(0, GFP_KERNEL); mouse->irq = usb_alloc_urb(0, GFP_KERNEL);
if (!mouse->irq) { if (!mouse->irq) {
pr_err("simple_mouse: Failed to allocate URB\n"); pr_err("simple_mouse: Failed to allocate URB\n");
goto fail_urb_alloc; goto fail_urb_alloc;
} }
/* Store references */ /* Store references */
mouse->usbdev = usbdev; mouse->usbdev = usbdev;
mouse->input_dev = input_dev; mouse->input_dev = input_dev;
/* Build device name from USB descriptors */ /* Build device name from USB descriptors */
if (usbdev->manufacturer) if (usbdev->manufacturer)
strscpy(mouse->name, usbdev->manufacturer, sizeof(mouse->name)); strscpy(mouse->name, usbdev->manufacturer, sizeof(mouse->name));
if (usbdev->product) { if (usbdev->product) {
if (usbdev->manufacturer) if (usbdev->manufacturer)
strlcat(mouse->name, " ", sizeof(mouse->name)); strlcat(mouse->name, " ", sizeof(mouse->name));
strlcat(mouse->name, usbdev->product, sizeof(mouse->name)); strlcat(mouse->name, usbdev->product, sizeof(mouse->name));
} }
/* Fallback name if no descriptors available */ /* Fallback name if no descriptors available */
if (! strlen(mouse->name)) { if (! strlen(mouse->name)) {
snprintf(mouse->name, sizeof(mouse->name), snprintf(mouse->name, sizeof(mouse->name),
"Simple USB Mouse %04x:%04x", "Simple USB Mouse %04x:%04x",
le16_to_cpu(usbdev->descriptor. idVendor), le16_to_cpu(usbdev->descriptor. idVendor),
le16_to_cpu(usbdev->descriptor.idProduct)); le16_to_cpu(usbdev->descriptor.idProduct));
} }
/* Build physical path */ /* Build physical path */
usb_make_path(usbdev, mouse->phys, sizeof(mouse->phys)); usb_make_path(usbdev, mouse->phys, sizeof(mouse->phys));
strlcat(mouse->phys, "/input0", sizeof(mouse->phys)); strlcat(mouse->phys, "/input0", sizeof(mouse->phys));
pr_info("simple_mouse: Device name: %s\n", mouse->name); pr_info("simple_mouse: Device name: %s\n", mouse->name);
pr_info("simple_mouse: Physical path: %s\n", mouse->phys); pr_info("simple_mouse: Physical path: %s\n", mouse->phys);
/* Configure input device */ /* Configure input device */
input_dev->name = mouse->name; input_dev->name = mouse->name;
input_dev->phys = mouse->phys; input_dev->phys = mouse->phys;
usb_to_input_id(usbdev, &input_dev->id); usb_to_input_id(usbdev, &input_dev->id);
input_dev->dev.parent = &intf->dev; input_dev->dev.parent = &intf->dev;
/* Set event types we can generate */ /* Set event types we can generate */
input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL); input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
/* Set button capabilities */ /* Set button capabilities */
input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) | input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE); BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) | input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
BIT_MASK(BTN_EXTRA); BIT_MASK(BTN_EXTRA);
/* Set relative axis capabilities */ /* Set relative axis capabilities */
input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y) | input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y) |
BIT_MASK(REL_WHEEL); BIT_MASK(REL_WHEEL);
/* Set driver data and callbacks */ /* Set driver data and callbacks */
input_set_drvdata(input_dev, mouse); input_set_drvdata(input_dev, mouse);
input_dev->open = simple_mouse_open; input_dev->open = simple_mouse_open;
input_dev->close = simple_mouse_close; input_dev->close = simple_mouse_close;
/* Initialize URB */ /* Initialize URB */
usb_fill_int_urb(mouse->irq, usbdev, pipe, mouse->data, usb_fill_int_urb(mouse->irq, usbdev, pipe, mouse->data,
(maxp > 8 ? 8 : maxp), (maxp > 8 ? 8 : maxp),
simple_mouse_irq, mouse, endpoint->bInterval); simple_mouse_irq, mouse, endpoint->bInterval);
mouse->irq->transfer_dma = mouse->data_dma; mouse->irq->transfer_dma = mouse->data_dma;
mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
/* Register input device with the kernel */ /* Register input device with the kernel */
error = input_register_device(mouse->input_dev); error = input_register_device(mouse->input_dev);
if (error) { if (error) {
pr_err("simple_mouse: Failed to register input device: %d\n", pr_err("simple_mouse: Failed to register input device: %d\n",
error); error);
goto fail_register; goto fail_register;
} }
/* Save our context in interface data */ /* Save our context in interface data */
usb_set_intfdata(intf, mouse); usb_set_intfdata(intf, mouse);
pr_info("simple_mouse: Probe successful!\n"); pr_info("simple_mouse: Probe successful!\n");
return 0; return 0;
/* Error handling - cleanup in reverse order */ /* Error handling - cleanup in reverse order */
fail_register: fail_register:
usb_free_urb(mouse->irq); usb_free_urb(mouse->irq);
fail_urb_alloc: fail_urb_alloc:
usb_free_coherent(usbdev, 8, mouse->data, mouse->data_dma); usb_free_coherent(usbdev, 8, mouse->data, mouse->data_dma);
fail_dma_alloc: fail_dma_alloc:
input_free_device(input_dev); input_free_device(input_dev);
fail_input_alloc: fail_input_alloc:
kfree(mouse); kfree(mouse);
return error; return error;
} }
/* /*
* Disconnect function - called when device is unplugged * Disconnect function - called when device is unplugged
*/ */
static void simple_mouse_disconnect(struct usb_interface *intf) static void simple_mouse_disconnect(struct usb_interface *intf)
{ {
struct simple_usb_mouse *mouse = usb_get_intfdata(intf); struct simple_usb_mouse *mouse = usb_get_intfdata(intf);
pr_info("simple_mouse: Device disconnected\n"); pr_info("simple_mouse: Device disconnected\n");
/* Clear interface data */ /* Clear interface data */
usb_set_intfdata(intf, NULL); usb_set_intfdata(intf, NULL);
if (mouse) { if (mouse) {
/* Stop URB */ /* Stop URB */
usb_kill_urb(mouse->irq); usb_kill_urb(mouse->irq);
/* Unregister from input subsystem */ /* Unregister from input subsystem */
input_unregister_device(mouse->input_dev); input_unregister_device(mouse->input_dev);
/* Free URB */ /* Free URB */
usb_free_urb(mouse->irq); usb_free_urb(mouse->irq);
/* Free DMA buffer */ /* Free DMA buffer */
usb_free_coherent(interface_to_usbdev(intf), 8, usb_free_coherent(interface_to_usbdev(intf), 8,
mouse->data, mouse->data_dma); mouse->data, mouse->data_dma);
/* Free context structure */ /* Free context structure */
kfree(mouse); kfree(mouse);
} }
} }
/* /*
* Device ID table - matches ANY USB HID Boot Protocol mouse * Device ID table - matches ANY USB HID Boot Protocol mouse
* This is the key to binding to any mouse! * This is the key to binding to any mouse!
*/ */
static const struct usb_device_id simple_mouse_id_table[] = { static const struct usb_device_id simple_mouse_id_table[] = {
{ {
USB_INTERFACE_INFO( USB_INTERFACE_INFO(
USB_INTERFACE_CLASS_HID, /* Class: HID */ USB_INTERFACE_CLASS_HID, /* Class: HID */
USB_INTERFACE_SUBCLASS_BOOT, /* Subclass: Boot */ USB_INTERFACE_SUBCLASS_BOOT, /* Subclass: Boot */
USB_INTERFACE_PROTOCOL_MOUSE /* Protocol: Mouse */ USB_INTERFACE_PROTOCOL_MOUSE /* Protocol: Mouse */
) )
}, },
{ } /* Terminating entry */ { } /* Terminating entry */
}; };
MODULE_DEVICE_TABLE(usb, simple_mouse_id_table); MODULE_DEVICE_TABLE(usb, simple_mouse_id_table);
/* /*
* USB Driver structure * USB Driver structure
*/ */
static struct usb_driver simple_mouse_driver = { static struct usb_driver simple_mouse_driver = {
.name = "simple_usb_mouse", .name = "simple_usb_mouse",
.probe = simple_mouse_probe, .probe = simple_mouse_probe,
.disconnect = simple_mouse_disconnect, .disconnect = simple_mouse_disconnect,
.id_table = simple_mouse_id_table, .id_table = simple_mouse_id_table,
}; };
/* /*
* Module init/exit * Module init/exit
*/ */
module_usb_driver(simple_mouse_driver); module_usb_driver(simple_mouse_driver);

232
usb_driver_manager.py
View File

@@ -6,6 +6,11 @@ and binding USB devices to new drivers.
Note: USB drivers typically bind to interfaces, not devices. This script Note: USB drivers typically bind to interfaces, not devices. This script
handles both device-level and interface-level driver binding. 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 import os
@@ -74,7 +79,7 @@ def get_usb_devices():
result = subprocess.run(['lsusb'], capture_output=True, text=True) result = subprocess.run(['lsusb'], capture_output=True, text=True)
for line in result.stdout.splitlines(): for line in result.stdout.splitlines():
# Format: Bus 001 Device 005: ID 046d:c52b Logitech, Inc. Unifying Receiver # 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: if match:
bus, dev, vendor, product, name = match.groups() bus, dev, vendor, product, name = match.groups()
key = f"{int(bus)}-{int(dev)}" 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...) # Only process actual device entries (format: busnum-devnum or busnum-port.port...)
device_name = device_path.name device_name = device_path.name
if not re.match(r'\d+-[\d.]+', device_name): if not re.match(r'\d+-[\d.]+$', device_name):
continue continue
# Skip root hubs # Skip root hubs
@@ -116,21 +121,9 @@ def get_usb_devices():
if driver_link.exists() and driver_link.is_symlink(): if driver_link.exists() and driver_link.is_symlink():
driver = driver_link.resolve().name 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 # Check interfaces for HID class and collect interface information
interfaces = [] interfaces = []
is_input = False
for interface_path in device_path.glob("*:*.*"): for interface_path in device_path.glob("*:*.*"):
if not interface_path.is_dir(): if not interface_path.is_dir():
continue continue
@@ -160,6 +153,12 @@ def get_usb_devices():
except Exception: except Exception:
continue 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({ devices.append({
'path': str(device_path), 'path': str(device_path),
'name': device_name, 'name': device_name,
@@ -172,7 +171,7 @@ def get_usb_devices():
'driver': driver, 'driver': driver,
'is_input': is_input, 'is_input': is_input,
'interfaces': interfaces, 'interfaces': interfaces,
'display_name': f"{manufacturer} {product}" 'display_name': f"{manufacturer} {product}".strip()
}) })
except Exception as e: except Exception as e:
@@ -217,42 +216,45 @@ def get_kernel_modules(directories=None):
modules = [] modules = []
seen_modules = set() # Track module names to avoid duplicates 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: for directory in directories:
if not os.path.exists(directory): if not os.path.exists(directory):
print_warning(f"Directory not found: {directory}") print_warning(f"Directory not found: {directory}")
continue 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 return modules
@@ -295,6 +297,55 @@ def get_user_choice(prompt, max_choice):
return None 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): def unbind_device(device, interface=None):
"""Unbind device interface from current driver""" """Unbind device interface from current driver"""
# If specific interface provided, unbind that interface # If specific interface provided, unbind that interface
@@ -355,8 +406,7 @@ def load_module(module):
"""Load kernel module""" """Load kernel module"""
try: try:
print(f"Loading module {module['name']}...") 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: if result.returncode == 0:
print_success(f"Successfully loaded {module['name']}") print_success(f"Successfully loaded {module['name']}")
return True return True
@@ -435,7 +485,7 @@ def bind_device(device, module, interface=None):
print_error(f"Failed to bind interface: {e}") print_error(f"Failed to bind interface: {e}")
return False 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 = [] target_interfaces = []
for iface in device.get('interfaces', []): for iface in device.get('interfaces', []):
# Look for HID Boot Mouse interfaces # Look for HID Boot Mouse interfaces
@@ -482,13 +532,35 @@ def bind_device(device, module, interface=None):
return success 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): def unload_module(module):
"""Unload kernel module""" """Unload kernel module"""
driver_name = get_module_driver_name(module) driver_name = get_module_driver_name(module)
try: try:
print(f"Unloading module {driver_name}...") 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: if result.returncode == 0:
print_success(f"Successfully unloaded {driver_name}") print_success(f"Successfully unloaded {driver_name}")
return True return True
@@ -562,12 +634,16 @@ def main():
print(f" Device: {selected_device['name']}") print(f" Device: {selected_device['name']}")
print(f" Current driver: {selected_device['driver']}") 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 # Step 3: List available kernel modules
if len(args.directories) > 1 or args.directories[0] != '.': if len(args.directories) > 1 or args.directories[0] != '.':
@@ -594,17 +670,14 @@ def main():
# Step 5: Confirm operation # Step 5: Confirm operation
print(f"\n{Colors.YELLOW}This will:{Colors.END}") 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: if module_already_loaded:
print(f" 2. Unload existing module {selected_module['name']}") print(f" 2. Unload existing module {selected_module['name']}")
print(f" 3. Load module {selected_module['name']} (fresh version)") 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: else:
print(f" 2. Load module {selected_module['name']}") 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() confirm = input(f"\n{Colors.BOLD}Proceed? (yes/no): {Colors.END}").strip().lower()
if confirm not in ['yes', 'y']: if confirm not in ['yes', 'y']:
@@ -614,10 +687,11 @@ def main():
# Step 6: Perform operations # Step 6: Perform operations
print_header("\nExecuting 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 # Unload module if already loaded
if module_already_loaded: if module_already_loaded:
@@ -631,24 +705,36 @@ def main():
# Load new module # Load new module
if not load_module(selected_module): if not load_module(selected_module):
print_error("Failed to load module. Attempting to restore...") 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) sys.exit(1)
# Give kernel time to auto-probe and bind # Give kernel time to auto-probe and bind
print("Waiting for kernel to probe interfaces...") print("Waiting for kernel to probe interfaces...")
time.sleep(0.5) 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) sys.exit(1)
# Success # Success
print_header("\nOperation completed successfully!") 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 # Offer to show new device status
print("\nVerifying device status...") print("\nVerifying device status...")