First implementation of Media Control

g29-wheel/Makefile

@@ -1,14 +0,0 @@
-
-.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

@@ -1,616 +0,0 @@
-// 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>
-
-#include "g29_usb.h"
-
-MODULE_AUTHOR("LLP group 16");
-MODULE_DESCRIPTION("Logitech G29 USB driver");
-MODULE_LICENSE("GPL");
-
-enum g29_mode {
-	G29_MODE_MEDIA = 0,
-	G29_MODE_WASD = 1,
-	G29_MODE_MOUSE = 2,
-};
-
-static int mode = G29_MODE_MEDIA;
-module_param(mode, int, 0644);
-MODULE_PARM_DESC(mode, "Initial mode (0=MEDIA, 1=WASD, 2=MOUSE)");
-
-/* Steering curve exponent (100 = linear, 200 = squared, 150 = ^1.5)
- * Higher values reduce sensitivity at low steering angles.
- */
-static int steer_curve = 200;
-module_param(steer_curve, int, 0644);
-MODULE_PARM_DESC(steer_curve, "Steering sensitivity curve (100=linear, 200=squared, default=200)");
-
-static int steer_deadzone = 10;
-module_param(steer_deadzone, int, 0644);
-MODULE_PARM_DESC(steer_deadzone, "Steering deadzone radius from center (default=10)");
-
-static int gas_curve = 100;
-module_param(gas_curve, int, 0644);
-MODULE_PARM_DESC(gas_curve, "Gas pedal sensitivity curve (100=linear, 200=squared, default=200)");
-
-static int clutch_curve = 100;
-module_param(clutch_curve, int, 0644);
-MODULE_PARM_DESC(clutch_curve, "Clutch pedal sensitivity curve (100=linear, 200=squared, default=200)");
-
-#define NORMALIZATION_PRECISION 1000
-
-struct g29_keymap {
-	u32 mask;
-	unsigned short keycode;
-};
-
-static const struct g29_keymap media_mode_keymap[] = {
-	/* 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 },
-};
-
-static const struct g29_keymap mouse_mode_keymap[] = {
-	{ G29_BTN_X,      BTN_LEFT },
-	{ G29_BTN_CIRCLE, BTN_RIGHT },
-	{ G29_BTN_TRIANGLE, BTN_MIDDLE },
-	{ G29_BTN_SQUARE, BTN_SIDE },
-};
-
-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;
-	struct timer_list mouse_timer;
-	u32 steer_phase_ms;
-
-	u32 phase_accumulator;
-	u32 gas_phase_accumulator;
-	u32 clutch_phase_accumulator;
-
-	enum g29_mode current_mode;
-	struct g29_state last;
-};
-
-
-
-static void g29_switch_mode(struct g29_dev *g29, enum g29_mode new_mode) {
-	if (g29->current_mode == new_mode)
-		return;
-
-	/* Stop timers when leaving modes */
-	if (g29->current_mode == G29_MODE_WASD) {
-		timer_delete_sync(&g29->steer_timer);
-	}
-	if (g29->current_mode == G29_MODE_MOUSE) {
-		timer_delete_sync(&g29->mouse_timer);
-	}
-
-	g29->current_mode = new_mode;
-	g29->phase_accumulator = 0;
-	g29->gas_phase_accumulator = 0;
-	g29->clutch_phase_accumulator = 0;
-
-	/* Start timers when entering modes */
-	if (new_mode == G29_MODE_WASD) {
-		mod_timer(&g29->steer_timer, jiffies + msecs_to_jiffies(2));
-	}
-	if (new_mode == G29_MODE_MOUSE) {
-		mod_timer(&g29->mouse_timer, jiffies + msecs_to_jiffies(10));
-	}
-
-	dev_info(&g29->udev->dev, "Switched to mode: %s\n",
-		 new_mode == G29_MODE_MEDIA ? "MEDIA" :
-		 new_mode == G29_MODE_WASD ? "WASD" : "MOUSE");
-}
-
-static int calc_adjusted_steering_distance(int distance) {
-	/* Apply non-linear steering curve:
-	 * adjusted = (distance / MAX)^(curve/100) * MAX
-	 *
-	 * For curve=200 (squared): 5% input -> 0.25% output, 50% -> 25%, 100% -> 100%
-	 * For curve=150 (^1.5):    5% input -> ~1.1% output, 50% -> ~35%, 100% -> 100%
-	 * For curve=100 (linear):  5% input -> 5% output (no change)
-	 *
-	 * Using integer math: adjusted = (distance^2 / MAX) for curve=200
-	 */
-	if (steer_curve == 100) {
-		return distance;
-	}
-	if (steer_curve == 200) {
-		return(distance * distance) / WHEEL_MAX_DIST;
-	}
-
-	/* Generic power curve using normalized values (0-1000 range for precision)
-	 * normalized = (distance * 1000) / WHEEL_MAX_DIST
-	 * Apply power approximation, then scale back
-	 */
-	int normalized = (distance * NORMALIZATION_PRECISION) / WHEEL_MAX_DIST;
-	int powered;
-
-	if (steer_curve == 150) {
-		/* Approximate ^1.5 with (x * sqrt(x)) */
-		int sqrt_norm = int_sqrt(normalized * NORMALIZATION_PRECISION);
-		powered = (normalized * sqrt_norm) / NORMALIZATION_PRECISION;
-	} else {
-		/* Fallback: squared for any other value > 100 */
-		powered = (normalized * normalized) / NORMALIZATION_PRECISION;
-	}
-
-	return (powered * WHEEL_MAX_DIST) / NORMALIZATION_PRECISION;
-}
-
-static int calc_adjusted_pedal_distance(int pedal_pressure, int curve) {
-	if (curve == 100) {
-		return pedal_pressure;
-	}
-	if (curve == 200) {
-		return (pedal_pressure * pedal_pressure) / G29_PEDAL_RELEASED;
-	}
-
-	int normalized = (pedal_pressure * NORMALIZATION_PRECISION) / G29_PEDAL_RELEASED;
-	int powered;
-
-	if (curve == 150) {
-		int sqrt_norm = int_sqrt(normalized * NORMALIZATION_PRECISION);
-		powered = (normalized * sqrt_norm) / NORMALIZATION_PRECISION;
-	} else {
-		powered = (normalized * normalized) / NORMALIZATION_PRECISION;
-	}
-
-	return (powered * G29_PEDAL_RELEASED) / NORMALIZATION_PRECISION;
-}
-
-static void mouse_mode_timer_fn(struct timer_list *t) {
-	struct g29_dev *g29 = timer_container_of(g29, t, mouse_timer);
-
-	const int rot = le16_to_cpu(g29->last.rot_le);
-	int gas_pressure = G29_PEDAL_RELEASED - g29->last.gas;
-	int clutch_pressure = G29_PEDAL_RELEASED - g29->last.clt;
-	
-	/* Calculate speed: positive for forward (gas), negative for backward (clutch) */
-	int speed = gas_pressure - clutch_pressure;
-	
-	/* Apply deadzone to steering */
-	int effective_rot = rot;
-	if (abs(rot - WHEEL_CENTER) <= steer_deadzone) {
-		effective_rot = WHEEL_CENTER;
-	}
-	
-	/* Calculate angle from wheel rotation
-	 * Map wheel rotation to angle: 
-	 * - Center (32768) = 0° (straight forward)
-	 * - Full left (0) = -180° (reverse)
-	 * - Full right (65535) = +180° (reverse)
-	 * We normalize to -1000 to +1000 representing -π to +π radians
-	 */
-	int angle_normalized = ((effective_rot - WHEEL_CENTER) * 1000) / WHEEL_CENTER;
-	
-	/* Clamp angle to prevent overflow */
-	if (angle_normalized > 1000) angle_normalized = 1000;
-	if (angle_normalized < -1000) angle_normalized = -1000;
-	
-	/* Calculate movement components using better trigonometric approximations:
-	 * dx = sin(angle) * speed
-	 * dy = cos(angle) * speed
-	 * 
-	 * sin(x) ≈ x - x³/6  (Taylor series)
-	 * cos(x) ≈ 1 - x²/2 + x⁴/24  (Taylor series)
-	 * 
-	 * For angle_normalized in [-1000, 1000] representing [-π, +π]:
-	 * This gives us full reverse when fully steered
-	 */
-	long angle_cubed = ((long)angle_normalized * angle_normalized * angle_normalized) / 1000000;
-	int sin_approx = (angle_normalized * 1000 - angle_cubed / 6) / 1000;
-	
-	long angle_squared = ((long)angle_normalized * angle_normalized) / 1000;
-	long angle_fourth = (angle_squared * angle_squared) / 1000;
-	int cos_approx = 1000 - angle_squared / 2 + angle_fourth / 24;
-	
-	int dx = (sin_approx * speed) / 1000;
-	int dy = -(cos_approx * speed) / 1000;  /* Negative because forward is -Y */
-	
-	/* Scale down the movement for reasonable mouse speed */
-	int scaled_dx = dx / 50;
-	int scaled_dy = dy / 50;
-	
-	/* Report mouse movement if there's any */
-	if (scaled_dx != 0 || scaled_dy != 0) {
-		input_report_rel(g29->input, REL_X, scaled_dx);
-		input_report_rel(g29->input, REL_Y, scaled_dy);
-		input_sync(g29->input);
-	}
-	
-	/* Reschedule timer if still in mouse mode */
-	if (g29->current_mode == G29_MODE_MOUSE)
-		mod_timer(&g29->mouse_timer, jiffies + msecs_to_jiffies(10));
-}
-static void wasd_mode_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);
-	
-	int effective_rot = rot;
-	int distance_from_center = abs(rot - WHEEL_CENTER);
-	if (distance_from_center <= steer_deadzone) {
-		effective_rot = WHEEL_CENTER;
-	}
-	
-	int distance_to_center = abs(effective_rot - WHEEL_CENTER);
-	int adjusted_distance = calc_adjusted_steering_distance(distance_to_center);
-
-	/* Phase accumulator approach:
-	 * Accumulate the adjusted distance on each tick.
-	 * When it exceeds the max distance, press the key and wrap.
-	 * This gives us a duty cycle of (adjusted_distance / WHEEL_MAX_DIST).
-	 *
-	 * Examples (with curve=200):
-	 *   5% steering  -> ~0.25% press rate
-	 *   50% steering -> 25% press rate
-	 *   100% steering -> 100% press rate (every tick)
-	 */
-	g29->phase_accumulator += adjusted_distance;
-
-	bool press_key;
-	if (g29->phase_accumulator >= WHEEL_MAX_DIST) {
-		g29->phase_accumulator -= WHEEL_MAX_DIST;
-		press_key = true;
-	} else {
-		press_key = false;
-	}
-
-	input_report_key(g29->input, KEY_A, press_key && (effective_rot < WHEEL_CENTER));
-	input_report_key(g29->input, KEY_D, press_key && (effective_rot >= WHEEL_CENTER));
-
-	/* Gas pedal (0xFF=up, 0x00=down) -> W key */
-	int gas_pressure = 0xFF - g29->last.gas;
-	int gas_adjusted = calc_adjusted_pedal_distance(gas_pressure, gas_curve);
-	g29->gas_phase_accumulator += gas_adjusted;
-
-	bool press_w = false;
-	if (g29->gas_phase_accumulator >= G29_PEDAL_RELEASED) {
-		g29->gas_phase_accumulator -= G29_PEDAL_RELEASED;
-		press_w = true;
-	}
-
-	/* Clutch pedal (0xFF=up, 0x00=down) -> S key */
-	int clutch_pressure = 0xFF - g29->last.clt;
-	int clutch_adjusted = calc_adjusted_pedal_distance(clutch_pressure, clutch_curve);
-	g29->clutch_phase_accumulator += clutch_adjusted;
-
-	bool press_s = false;
-	if (g29->clutch_phase_accumulator >= G29_PEDAL_RELEASED) {
-		g29->clutch_phase_accumulator -= G29_PEDAL_RELEASED;
-		press_s = true;
-	}
-
-	input_report_key(g29->input, KEY_W, press_w);
-	input_report_key(g29->input, KEY_S, press_s);
-
-	input_sync(g29->input);
-
-	if (g29->current_mode == G29_MODE_WASD)
-		mod_timer(&g29->steer_timer, jiffies + msecs_to_jiffies(2));
-}
-
-static void process_media_mode(struct g29_dev *g29, const struct g29_state *cur, const struct g29_state *prev) {
-	const u32 pressed = le32_to_cpu(cur->buttons_le & ~prev->buttons_le);
-	const u32 released = le32_to_cpu(~cur->buttons_le & prev->buttons_le);
-	for (int i = 0; i < ARRAY_SIZE(media_mode_keymap); i++) {
-		const struct g29_keymap *k = &media_mode_keymap[i];
-		if (pressed & k->mask) {
-			input_report_key(g29->input, k->keycode, 1);
-		}
-		if (released & k->mask) {
-			input_report_key(g29->input, k->keycode, 0);
-		}
-	}
-	input_sync(g29->input);
-}
-
-static void process_wasd_mode(struct g29_dev *g29, const struct g29_state *cur, const struct g29_state *prev) {
-	/* WASD mode is handled by the timer function (g29_steer_timer_fn) */
-	/* No additional processing needed here */
-}
-
-static void process_mouse_mode(struct g29_dev *g29, const struct g29_state *cur, const struct g29_state *prev) {
-	const u32 pressed = le32_to_cpu(cur->buttons_le & ~prev->buttons_le);
-	const u32 released = le32_to_cpu(~cur->buttons_le & prev->buttons_le);
-
-	for (int i = 0; i < ARRAY_SIZE(mouse_mode_keymap); i++) {
-		const struct g29_keymap *k = &mouse_mode_keymap[i];
-		if (pressed & k->mask) {
-			input_report_key(g29->input, k->keycode, 1);
-		}
-		if (released & k->mask) {
-			input_report_key(g29->input, k->keycode, 0);
-		}
-	}
-
-	if (pressed & G29_BTN_RED_CW) {
-		input_report_rel(g29->input, REL_WHEEL, 1);
-	}
-	if (pressed & G29_BTN_RED_CCW) {
-		input_report_rel(g29->input, REL_WHEEL, -1);
-	}
-	
-	input_sync(g29->input);
-}
-
-static void g29_check_mode_switch(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);
-	
-	if (pressed & G29_BTN_SHARE) {
-		g29_switch_mode(g29, G29_MODE_MEDIA);
-	} else if (pressed & G29_BTN_OPTION) {
-		g29_switch_mode(g29, G29_MODE_WASD);
-	} else if (pressed & G29_BTN_PS3_LOGO) {
-		g29_switch_mode(g29, G29_MODE_MOUSE);
-	}
-}
-
-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;
-	
-	g29_check_mode_switch(g29, cur, &g29->last);
-	
-	switch (g29->current_mode) {
-		case G29_MODE_MEDIA:
-			process_media_mode(g29, cur, &g29->last);
-			break;
-		case G29_MODE_WASD:
-			process_wasd_mode(g29, cur, &g29->last);
-			break;
-		case G29_MODE_MOUSE:
-			process_mouse_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;
-
-	g29_switch_mode(g29, mode);
-
-	return 0;
-}
-
-static void g29_input_close(struct input_dev *input) {
-	struct g29_dev *g29 = input_get_drvdata(input);
-	
-	if (g29->current_mode == G29_MODE_WASD)
-		timer_delete_sync(&g29->steer_timer);
-	if (g29->current_mode == G29_MODE_MOUSE)
-		timer_delete_sync(&g29->mouse_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));
-	g29->current_mode = mode;  /* Initialize to module parameter */
-
-	timer_setup(&g29->steer_timer, wasd_mode_timer_fn, 0);
-	timer_setup(&g29->mouse_timer, mouse_mode_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);
-	__set_bit(EV_REL, input->evbit);
-
-	/* Media mode keys */
-	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);
-
-	/* WASD mode keys */
-	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);
-
-	/* Mouse mode capabilities */
-	input_set_capability(input, EV_KEY, BTN_LEFT);
-	input_set_capability(input, EV_KEY, BTN_RIGHT);
-	input_set_capability(input, EV_KEY, BTN_MIDDLE);
-	input_set_capability(input, EV_REL, REL_X);
-	input_set_capability(input, EV_REL, REL_Y);
-	input_set_capability(input, EV_REL, REL_WHEEL);
-
-	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);

g29-wheel/g29_usb.h

@@ -1,76 +0,0 @@
-/*
- * Logitech G29 USB/HID Protocol Definitions
- */
-
-#ifndef G29_USB_H
-#define G29_USB_H
-
-#include <linux/types.h>
-
-#define USB_VENDOR_ID_LOGITECH      0x046d
-#define USB_DEVICE_ID_LOGITECH_G29  0xc24f
-#define USB_DEVICE_ID_LOGITECH_G29_ALT 0xc260
-
-#define G29_BTN_X           0x00000010u
-#define G29_BTN_SQUARE      0x00000020u
-#define G29_BTN_CIRCLE      0x00000040u
-#define G29_BTN_TRIANGLE    0x00000080u
-#define G29_BTN_R1          0x00000100u
-#define G29_BTN_L1          0x00000200u
-#define G29_BTN_R2          0x00000400u
-#define G29_BTN_L2          0x00000800u
-#define G29_BTN_SHARE       0x00001000u
-#define G29_BTN_OPTION      0x00002000u
-#define G29_BTN_R3          0x00004000u
-#define G29_BTN_L3          0x00008000u
-#define G29_BTN_GEAR_1      0x00010000u
-#define G29_BTN_GEAR_2      0x00020000u
-#define G29_BTN_GEAR_3      0x00040000u
-#define G29_BTN_GEAR_4      0x00080000u
-#define G29_BTN_GEAR_5      0x00100000u
-#define G29_BTN_GEAR_6      0x00200000u
-#define G29_BTN_GEAR_REV    0x00400000u
-#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_PS3_LOGO     0xF0000000u
-
-#define G29_DPAD_MASK       0x0000000Eu
-#define G29_DPAD_UP         0x00000000u
-#define G29_DPAD_RIGHT      0x00000002u
-#define G29_DPAD_DOWN       0x00000004u
-#define G29_DPAD_LEFT       0x00000006u
-#define G29_DPAD_NONE       0x00000008u
-
-#define G29_WHEEL_MIN_ROTATION           0x0000
-#define G29_WHEEL_MAX_ROTATION           0xFFFF
-
-#define G29_PEDAL_RELEASED      0xFF
-#define G29_PEDAL_PRESSED       0x00
-#define G29_PEDAL_THRESHOLD     0x80
-
-#define G29_GEARSHIFT_X_LEFT    0x30   /* Gears 1-2 */
-#define G29_GEARSHIFT_X_CENTER  0x80   /* Gears 3-4 */
-#define G29_GEARSHIFT_X_RIGHT   0xB0   /* Gears 5-6-R */
-#define G29_GEARSHIFT_Y_TOP     0xD0   /* Gears 1-3-5 */
-#define G29_GEARSHIFT_Y_BOTTOM  0x40   /* Gears 2-4-6-R */
-#define G29_GEARSHIFT_Z_NEUTRAL 0x9C   /* Neutral position */
-#define G29_GEARSHIFT_Z_PRESSED 0xDC   /* Pressed down */
-
-#define WHEEL_CENTER        32768
-#define WHEEL_MAX_DIST      32768
-
-struct g29_state {
-	u32 buttons_le;  /* Button bitmask (little-endian) */
-	u16 rot_le;      /* Wheel rotation (little-endian) */
-	u8 gas;          /* Gas pedal (0xFF=up, 0x00=down) */
-	u8 brk;          /* Brake pedal (0xFF=up, 0x00=down) */
-	u8 clt;          /* Clutch pedal (0xFF=up, 0x00=down) */
-	u8 gr_x;         /* Gearshift X-axis */
-	u8 gr_y;         /* Gearshift Y-axis */
-	u8 gr_z;         /* Gearshift Z-axis */
-} __packed;
-
-#endif

g29_media_usb/Makefile

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

g29_media_usb/g29_media_usb.c

@@ -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);

logitech-G29.md

@@ -1,70 +0,0 @@
-
-Logitech G29 USB Protocol
-=========================
-
-- 12 bytes per event
-- Little-endian (= smaller value bytes first)
-
-```
-                                          1
-  0   1   2   3   4   5   6   7   8   9   0   1
-+---+---+---+---+---+---+---+---+---+---+---+---+
-|    Buttons    |  Rot  |Gas|Brk|Clt|GrX|GrY|GrZ|
-+---+---+---+---+---+---+---+---+---+---+---+---+
-```
-
-- `Buttons`: Bitmask of pressed buttons (mask values are in big endian).
-    - `0x00000001` - ?
-    - `0x0000000E` - Arrow keys
-        - `0x00000000` - Up
-        - `0x00000002` - Right
-        - `0x00000004` - Down
-        - `0x00000006` - Left
-        - `0x00000008` - No arrow key pressed
-    - `0x00000010` - X
-    - `0x00000020` - Square
-    - `0x00000040` - Circle
-    - `0x00000080` - Triangle
-    - `0x00000100` - R1
-    - `0x00000200` - L1
-    - `0x00000400` - R2
-    - `0x00000800` - L2
-    - `0x00001000` - Share
-    - `0x00002000` - Option
-    - `0x00004000` - R3
-    - `0x00008000` - L3
-    - `0x00010000` - Gear 1
-    - `0x00020000` - Gear 2
-    - `0x00040000` - Gear 3
-    - `0x00080000` - Gear 4
-    - `0x00100000` - Gear 5
-    - `0x00200000` - Gear 6
-    - `0x00400000` - Gear reverse
-    - `0x00800000` - Plus
-    - `0x01000000` - Minus
-    - `0x02000000` - Red rotation clockwise
-    - `0x04000000` - Red rotation counterclockwise
-    - `0x08000000` - Return
-    - `0xF0000000` - Playstation 3 Logo Button (verify)
-- `Rot`: Wheel rotation (little-endian). `0x0000` (leftmost) - `0xFFFF` (rightmost).
-- `Gas`: Gas pedal. `0xFF` (up, default) - `0x00` (down).
-- `Brk`: Brake pedal. `0xFF` (up, default) - `0x00` (down).
-- `Clt`: Clutch pedal. `0xFF` (up, default) - `0x00` (down).
-- `GrX`: Gearshift X axis. ~`0x30` (gear 1+2), ~`0x80` (gear 3+4), ~`0xB0` (gear 5+6+reverse).
-- `GrY`: Gearshift Y axis. ~`0xD0` (gear 1+3+5), ~`0x40` (gear 2+4+6+reverse).
-- `GrZ`: Gearshift Z axis. ~`0x9C` (neutral), ~`0xDC` (pressed down).
-
-
-## Sample event
-
-Sample event:
-```
-08 00 00 00   00 80   ff ff ff   81 80 9c
-```
-
-* No buttons pressed / no gear engaged
-* Wheel rotation at `0x8000` ~ center
-* Gas pedal up
-* Brake pedal up
-* Clutch pedal up
-* Gearshift neutral

mouse/Makefile

@@ -1,39 +1,23 @@
-obj-m += simple_usb_mouse.o
-obj-m += gesture_usb_mouse.o
-
-PWD := $(CURDIR)
-KDIR := /lib/modules/$(shell uname -r)/build
-
-# Function to organize build artifacts
-# Usage: $(call organize_build,pattern)
-define organize_build
-	mkdir -p build
-	mv -f *.o *.ko *.mod *.mod.c Module.symvers modules.order build/ 2>/dev/null || true
-	find . -maxdepth 1 -name '.*.cmd' -exec mv {} build/ \; 2>/dev/null || true
-	find . -maxdepth 1 -name '.*.o' -exec mv {} build/ \; 2>/dev/null || true
-	[ -d .tmp_versions ] && mv .tmp_versions build/ || true
-endef
-
-all:
-	make -C $(KDIR) M=$(PWD) modules
-	$(call organize_build)
-simple:
-	make -C $(KDIR) M=$(PWD) simple_usb_mouse.ko
-	$(call organize_build)
-
-gesture:
-	make -C $(KDIR) M=$(PWD) gesture_usb_mouse.ko
-	$(call organize_build)
-
-clean:
-	make -C $(KDIR) M=$(PWD) clean
-	rm -rf build
-
-install:
-	make -C $(KDIR) M=$(PWD) modules_install
-	depmod -a
-
-uninstall:
-	rm -f /lib/modules/$(shell uname -r)/kernel/drivers/usb/input/simple_usb_mouse.ko
-	rm -f /lib/modules/$(shell uname -r)/kernel/drivers/usb/input/gesture_usb_mouse.ko
-	depmod -a
+obj-m += simple_usb_mouse.o
+
+PWD := $(CURDIR)
+
+all:
+	make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
+	mkdir -p build
+	mv -f *.o *.ko *.mod *.mod.c Module.symvers modules.order build/ 2>/dev/null || true
+	find . -maxdepth 1 -name '.*.cmd' -exec mv {} build/ \; 2>/dev/null || true
+	find . -maxdepth 1 -name '.*.o' -exec mv {} build/ \; 2>/dev/null || true
+	[ -d .tmp_versions ] && mv .tmp_versions build/ || 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:
+	rm -f /lib/modules/$(shell uname -r)/kernel/drivers/usb/input/simple_usb_mouse.ko
+	depmod -a

mouse/gesture_usb_mouse.c

@@ -1,675 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * Gesture USB Mouse Driver
- *
- * A USB HID Boot Protocol mouse driver with gesture recognition.
- * Detects shapes like "C" (copy) and "V" (paste) and sends keyboard events.
- * Based on simple_usb_mouse.c
- */
-
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/module.h>
-#include <linux/init.h>
-#include <linux/usb.h>
-#include <linux/usb/input.h>
-#include <linux/hid.h>
-#include <linux/input.h>
-#include <linux/jiffies.h>
-
-#define DRIVER_AUTHOR "Testor"
-#define DRIVER_DESC "Gesture USB Mouse Driver"
-
-MODULE_AUTHOR(DRIVER_AUTHOR);
-MODULE_DESCRIPTION(DRIVER_DESC);
-MODULE_LICENSE("GPL");
-
-/* Gesture detection parameters */
-#define HISTORY_SIZE 100            /* Number of movement samples to track */
-#define GESTURE_MIN_DISTANCE 150    /* Minimum total distance for gesture */
-#define GESTURE_TIMEOUT_MS 1500     /* Max time for a gesture (ms) */
-#define MOVEMENT_THRESHOLD 3        /* Ignore tiny movements (noise reduction) */
-
-/* Module parameters for tuning */
-static int gesture_enabled = 1;
-module_param(gesture_enabled, int, 0644);
-MODULE_PARM_DESC(gesture_enabled, "Enable gesture recognition (default: 1)");
-
-static int gesture_min_distance = GESTURE_MIN_DISTANCE;
-module_param(gesture_min_distance, int, 0644);
-MODULE_PARM_DESC(gesture_min_distance, "Minimum distance for gesture detection");
-
-static int debug_gestures = 0;
-module_param(debug_gestures, int, 0644);
-MODULE_PARM_DESC(debug_gestures, "Print debug info for gestures (default: 0)");
-
-static int gesture_button = 2;
-module_param(gesture_button, int, 0644);
-MODULE_PARM_DESC(gesture_button, "Button for gestures (1=left, 2=middle, 3=right, default: 2)");
-
-/*
- * Movement point for gesture tracking
- */
-struct movement_point {
-    int16_t x;
-    int16_t y;
-    unsigned long timestamp;
-};
-
-/*
- * Gesture statistics for debugging
- */
-struct gesture_stats {
-    unsigned long c_detected;
-    unsigned long v_detected;
-    unsigned long invalid;
-};
-
-/*
- * Driver context structure
- */
-struct gesture_usb_mouse {
-    char name[128];
-    char phys[64];
-    struct usb_device *usbdev;
-    struct input_dev *input_dev;
-    struct urb *irq;
-    unsigned char *data;
-    dma_addr_t data_dma;
-
-    /* Gesture detection state */
-    struct movement_point history[HISTORY_SIZE];
-    int history_index;
-    int history_count;
-    unsigned long gesture_start_time;
-    int total_distance;
-    bool gesture_in_progress;
-    bool gesture_button_held;
-
-    /* Statistics */
-    struct gesture_stats stats;
-};
-
-/*
- * Calculate distance between two points
- */
-static int calculate_distance(int16_t x1, int16_t y1, int16_t x2, int16_t y2)
-{
-    int dx = x2 - x1;
-    int dy = y2 - y1;
-    /* Approximate distance: max(|dx|, |dy|) + min(|dx|, |dy|)/2 */
-    int adx = dx < 0 ? -dx : dx;
-    int ady = dy < 0 ? -dy : dy;
-    return (adx > ady) ? (adx + ady/2) : (ady + adx/2);
-}
-
-/*
- * Send keyboard shortcut
- */
-static void send_keyboard_shortcut(struct input_dev *dev, unsigned int key)
-{
-    /* Press Ctrl+Key */
-    input_report_key(dev, KEY_LEFTCTRL, 1);
-    input_report_key(dev, key, 1);
-    input_sync(dev);
-
-    /* Release Key+Ctrl */
-    input_report_key(dev, key, 0);
-    input_report_key(dev, KEY_LEFTCTRL, 0);
-    input_sync(dev);
-}
-
-/*
- * Detect "C" shape gesture
- * C shape: starts from right, curves left and down, then right
- * Pattern: movement goes left with downward curve, then curves back right
- */
-static bool detect_c_gesture(struct gesture_usb_mouse *mouse)
-{
-    int i;
-    int left_count = 0, right_count = 0;
-    int down_count = 0, up_count = 0;
-    int start_idx, end_idx;
-    int16_t start_x, start_y, end_x, end_y;
-    int width, height;
-
-    if (mouse->history_count < 20)
-        return false;
-
-    /* Get start and end points */
-    start_idx = (mouse->history_index - mouse->history_count + HISTORY_SIZE) % HISTORY_SIZE;
-    end_idx = (mouse->history_index - 1 + HISTORY_SIZE) % HISTORY_SIZE;
-
-    start_x = mouse->history[start_idx].x;
-    start_y = mouse->history[start_idx].y;
-    end_x = mouse->history[end_idx].x;
-    end_y = mouse->history[end_idx].y;
-
-    /* Analyze movement directions */
-    for (i = 1; i < mouse->history_count; i++) {
-        int idx = (start_idx + i) % HISTORY_SIZE;
-        int prev_idx = (start_idx + i - 1 + HISTORY_SIZE) % HISTORY_SIZE;
-
-        int16_t dx = mouse->history[idx].x - mouse->history[prev_idx].x;
-        int16_t dy = mouse->history[idx].y - mouse->history[prev_idx].y;
-
-        if (dx < -MOVEMENT_THRESHOLD) left_count++;
-        if (dx > MOVEMENT_THRESHOLD) right_count++;
-        if (dy < -MOVEMENT_THRESHOLD) up_count++;
-        if (dy > MOVEMENT_THRESHOLD) down_count++;
-    }
-
-    width = (end_x > start_x) ? (end_x - start_x) : (start_x - end_x);
-    height = (end_y > start_y) ? (end_y - start_y) : (start_y - end_y);
-
-    /* C shape criteria:
-     * - More leftward movement than rightward (opening faces left)
-     * - Significant downward movement
-     * - Start and end X positions are similar (closed C shape)
-     * - Height is reasonable compared to width
-     */
-    bool is_c = (left_count * 2 > right_count * 3) &&
-                (down_count > up_count) &&
-                (width > 40) &&
-                (height > 30) &&
-                (width < height * 2);
-
-    if (debug_gestures && is_c) {
-        pr_info("gesture_mouse: C detected - L:%d R:%d D:%d U:%d W:%d H:%d\n",
-                left_count, right_count, down_count, up_count, width, height);
-    }
-
-    return is_c;
-}
-
-/*
- * Detect "V" shape gesture
- * V shape: starts up, goes down-right or down-left, then up in opposite direction
- * Pattern: down-slope followed by up-slope
- */
-static bool detect_v_gesture(struct gesture_usb_mouse *mouse)
-{
-    int i, turning_point = -1;
-    int down_before = 0, up_after = 0;
-    int start_idx, end_idx;
-    int16_t start_y, end_y, lowest_y;
-    int height_before = 0, height_after = 0;
-
-    if (mouse->history_count < 15)
-        return false;
-
-    start_idx = (mouse->history_index - mouse->history_count + HISTORY_SIZE) % HISTORY_SIZE;
-    end_idx = (mouse->history_index - 1 + HISTORY_SIZE) % HISTORY_SIZE;
-
-    start_y = mouse->history[start_idx].y;
-    end_y = mouse->history[end_idx].y;
-    lowest_y = start_y;
-
-    /* Find the turning point (lowest Y value) */
-    for (i = 0; i < mouse->history_count; i++) {
-        int idx = (start_idx + i) % HISTORY_SIZE;
-        if (mouse->history[idx].y > lowest_y) {
-            lowest_y = mouse->history[idx].y;
-            turning_point = i;
-        }
-    }
-
-    if (turning_point <= 0 || turning_point >= mouse->history_count - 1)
-        return false;
-
-    /* Count down movements before turning point */
-    for (i = 1; i <= turning_point; i++) {
-        int idx = (start_idx + i) % HISTORY_SIZE;
-        int prev_idx = (start_idx + i - 1 + HISTORY_SIZE) % HISTORY_SIZE;
-
-        int16_t dy = mouse->history[idx].y - mouse->history[prev_idx].y;
-        if (dy > MOVEMENT_THRESHOLD) {
-            down_before++;
-            height_before += dy;
-        }
-    }
-
-    /* Count up movements after turning point */
-    for (i = turning_point + 1; i < mouse->history_count; i++) {
-        int idx = (start_idx + i) % HISTORY_SIZE;
-        int prev_idx = (start_idx + i - 1 + HISTORY_SIZE) % HISTORY_SIZE;
-
-        int16_t dy = mouse->history[idx].y - mouse->history[prev_idx].y;
-        if (dy < -MOVEMENT_THRESHOLD) {
-            up_after++;
-            height_after -= dy;
-        }
-    }
-
-    /* V shape criteria:
-     * - Significant downward movement in first half
-     * - Significant upward movement in second half
-     * - Both sides have reasonable height
-     * - Turning point is roughly in the middle
-     */
-    bool is_v = (down_before > 5) &&
-                (up_after > 5) &&
-                (height_before > 40) &&
-                (height_after > 40) &&
-                (turning_point > mouse->history_count / 4) &&
-                (turning_point < mouse->history_count * 3 / 4);
-
-    if (debug_gestures && is_v) {
-        pr_info("gesture_mouse: V detected - Down:%d Up:%d HB:%d HA:%d Turn:%d/%d\n",
-                down_before, up_after, height_before, height_after,
-                turning_point, mouse->history_count);
-    }
-
-    return is_v;
-}
-
-/*
- * Process accumulated gesture data
- */
-static void process_gesture(struct gesture_usb_mouse *mouse)
-{
-    if (!gesture_enabled)
-        return;
-
-    if (mouse->total_distance < gesture_min_distance) {
-        if (debug_gestures)
-            pr_info("gesture_mouse: Gesture too short (%d < %d)\n",
-                    mouse->total_distance, gesture_min_distance);
-        return;
-    }
-
-    /* Try to detect gestures */
-    if (detect_c_gesture(mouse)) {
-        pr_info("gesture_mouse: C gesture detected - triggering COPY\n");
-        send_keyboard_shortcut(mouse->input_dev, KEY_C);
-        mouse->stats.c_detected++;
-    } else if (detect_v_gesture(mouse)) {
-        pr_info("gesture_mouse: V gesture detected - triggering PASTE\n");
-        send_keyboard_shortcut(mouse->input_dev, KEY_V);
-        mouse->stats.v_detected++;
-    } else {
-        if (debug_gestures)
-            pr_info("gesture_mouse: No gesture matched (distance: %d, samples: %d)\n",
-                    mouse->total_distance, mouse->history_count);
-        mouse->stats.invalid++;
-    }
-}
-
-/*
- * Reset gesture tracking state
- */
-static void reset_gesture_tracking(struct gesture_usb_mouse *mouse)
-{
-    mouse->history_count = 0;
-    mouse->history_index = 0;
-    mouse->gesture_in_progress = false;
-    mouse->total_distance = 0;
-    mouse->gesture_start_time = 0;
-}
-
-/*
- * Add movement to gesture history
- */
-static void add_movement(struct gesture_usb_mouse *mouse, int16_t dx, int16_t dy)
-{
-    struct movement_point *point;
-    int distance;
-
-    if (!mouse->gesture_in_progress)
-        return;
-
-    /* Ignore very small movements (noise) */
-    if (dx < MOVEMENT_THRESHOLD && dx > -MOVEMENT_THRESHOLD &&
-        dy < MOVEMENT_THRESHOLD && dy > -MOVEMENT_THRESHOLD)
-        return;
-
-    /* Check for timeout */
-    if (time_after(jiffies, mouse->gesture_start_time + msecs_to_jiffies(GESTURE_TIMEOUT_MS))) {
-        if (debug_gestures)
-            pr_info("gesture_mouse: Gesture timeout\n");
-        process_gesture(mouse);
-        reset_gesture_tracking(mouse);
-        return;
-    }
-
-    /* Calculate cumulative position */
-    point = &mouse->history[mouse->history_index];
-    if (mouse->history_count > 0) {
-        int prev_idx = (mouse->history_index - 1 + HISTORY_SIZE) % HISTORY_SIZE;
-        point->x = mouse->history[prev_idx].x + dx;
-        point->y = mouse->history[prev_idx].y + dy;
-
-        distance = calculate_distance(mouse->history[prev_idx].x, mouse->history[prev_idx].y,
-                                       point->x, point->y);
-        mouse->total_distance += distance;
-    } else {
-        point->x = 0;
-        point->y = 0;
-    }
-
-    point->timestamp = jiffies;
-
-    mouse->history_index = (mouse->history_index + 1) % HISTORY_SIZE;
-    if (mouse->history_count < HISTORY_SIZE)
-        mouse->history_count++;
-}
-
-/*
- * IRQ handler - called when mouse sends data
- */
-static void gesture_mouse_irq(struct urb *urb)
-{
-    struct gesture_usb_mouse *mouse = urb->context;
-    unsigned char *data = mouse->data;
-    struct input_dev *dev = mouse->input_dev;
-    int status;
-    int16_t x_movement, y_movement;
-    bool gesture_button_pressed;
-
-    /* Check URB status */
-    switch (urb->status) {
-        case 0:
-            break;
-        case -ECONNRESET:
-        case -ENOENT:
-        case -ESHUTDOWN:
-            pr_debug("gesture_mouse: URB stopped (status %d)\n", urb->status);
-            return;
-        default:
-            pr_debug("gesture_mouse: URB error (status %d)\n", urb->status);
-            goto resubmit;
-    }
-
-    /* Extract movement data */
-    x_movement = (int16_t)(data[2] | (data[3] << 8));
-    y_movement = (int16_t)(data[4] | (data[5] << 8));
-
-    /* Determine which button activates gestures */
-    switch (gesture_button) {
-        case 1: gesture_button_pressed = (data[0] & 0x01) != 0; break;  /* Left */
-        case 2: gesture_button_pressed = (data[0] & 0x04) != 0; break;  /* Middle */
-        case 3: gesture_button_pressed = (data[0] & 0x02) != 0; break;  /* Right */
-        default: gesture_button_pressed = false; break;
-    }
-
-    /* Gesture tracking logic */
-    if (gesture_enabled && gesture_button != 0) {
-        /* Start gesture when gesture button is pressed */
-        if (gesture_button_pressed && !mouse->gesture_button_held) {
-            reset_gesture_tracking(mouse);
-            mouse->gesture_in_progress = true;
-            mouse->gesture_start_time = jiffies;
-            if (debug_gestures)
-                pr_info("gesture_mouse: Gesture started\n");
-        }
-
-        /* Track movements while gesture button is held */
-        if (gesture_button_pressed && mouse->gesture_in_progress) {
-            add_movement(mouse, x_movement, y_movement);
-        }
-
-        /* End gesture when gesture button is released */
-        if (!gesture_button_pressed && mouse->gesture_button_held && mouse->gesture_in_progress) {
-            if (debug_gestures)
-                pr_info("gesture_mouse: Gesture ended (dist: %d, samples: %d)\n",
-                        mouse->total_distance, mouse->history_count);
-            process_gesture(mouse);
-            reset_gesture_tracking(mouse);
-        }
-
-        mouse->gesture_button_held = gesture_button_pressed;
-    }
-
-    /* Report normal mouse events */
-    input_report_key(dev, BTN_LEFT,   data[0] & 0x01);
-    input_report_key(dev, BTN_RIGHT,  data[0] & 0x02);
-    //input_report_key(dev, BTN_MIDDLE, data[0] & 0x04);
-    input_report_key(dev, BTN_SIDE,   data[0] & 0x08);
-    input_report_key(dev, BTN_EXTRA,  data[0] & 0x10);
-
-    input_report_rel(dev, REL_X, x_movement);
-    input_report_rel(dev, REL_Y, y_movement);
-    input_report_rel(dev, REL_WHEEL, (signed char) data[6]);
-
-    input_sync(dev);
-
-resubmit:
-    status = usb_submit_urb(urb, GFP_ATOMIC);
-    if (status) {
-        dev_err(&mouse->usbdev->dev,
-                "Failed to resubmit URB: %d\n", status);
-    }
-}
-
-/*
- * Device open callback
- */
-static int gesture_mouse_open(struct input_dev *dev)
-{
-    struct gesture_usb_mouse *mouse = input_get_drvdata(dev);
-
-    pr_info("gesture_mouse: Device opened\n");
-
-    mouse->irq->dev = mouse->usbdev;
-    if (usb_submit_urb(mouse->irq, GFP_KERNEL)) {
-        pr_err("gesture_mouse: Failed to submit URB on open\n");
-        return -EIO;
-    }
-
-    return 0;
-}
-
-/*
- * Device close callback
- */
-static void gesture_mouse_close(struct input_dev *dev)
-{
-    struct gesture_usb_mouse *mouse = input_get_drvdata(dev);
-
-    pr_info("gesture_mouse: Device closed\n");
-    pr_info("gesture_mouse: Stats - C:%lu V:%lu Invalid:%lu\n",
-            mouse->stats.c_detected, mouse->stats.v_detected, mouse->stats.invalid);
-    usb_kill_urb(mouse->irq);
-}
-
-/*
- * Probe function
- */
-static int gesture_mouse_probe(struct usb_interface *intf,
-                               const struct usb_device_id *id)
-{
-    struct usb_device *usbdev = interface_to_usbdev(intf);
-    struct usb_host_interface *interface;
-    struct usb_endpoint_descriptor *endpoint;
-    struct gesture_usb_mouse *mouse;
-    struct input_dev *input_dev;
-    int pipe, maxp;
-    int error = -ENOMEM;
-
-    pr_info("gesture_mouse: Probing device %04x:%04x\n",
-            le16_to_cpu(usbdev->descriptor.idVendor),
-            le16_to_cpu(usbdev->descriptor.idProduct));
-
-    interface = intf->cur_altsetting;
-
-    if (interface->desc.bNumEndpoints != 1) {
-        pr_err("gesture_mouse: Interface has %d endpoints (expected 1)\n",
-               interface->desc.bNumEndpoints);
-        return -ENODEV;
-    }
-
-    endpoint = &interface->endpoint[0].desc;
-
-    if (!usb_endpoint_is_int_in(endpoint)) {
-        pr_err("gesture_mouse: Endpoint is not interrupt IN\n");
-        return -ENODEV;
-    }
-
-    pipe = usb_rcvintpipe(usbdev, endpoint->bEndpointAddress);
-    maxp = usb_maxpacket(usbdev, pipe);
-
-    mouse = kzalloc(sizeof(struct gesture_usb_mouse), GFP_KERNEL);
-    if (!mouse)
-        return -ENOMEM;
-
-    input_dev = input_allocate_device();
-    if (!input_dev) {
-        pr_err("gesture_mouse: Failed to allocate input device\n");
-        goto fail_input_alloc;
-    }
-
-    mouse->data = usb_alloc_coherent(usbdev, 8, GFP_KERNEL, &mouse->data_dma);
-    if (!mouse->data) {
-        pr_err("gesture_mouse: Failed to allocate DMA buffer\n");
-        goto fail_dma_alloc;
-    }
-
-    mouse->irq = usb_alloc_urb(0, GFP_KERNEL);
-    if (!mouse->irq) {
-        pr_err("gesture_mouse: Failed to allocate URB\n");
-        goto fail_urb_alloc;
-    }
-
-    mouse->usbdev = usbdev;
-    mouse->input_dev = input_dev;
-
-    /* Build device name */
-    if (usbdev->manufacturer)
-        strscpy(mouse->name, usbdev->manufacturer, sizeof(mouse->name));
-
-    if (usbdev->product) {
-        if (usbdev->manufacturer)
-            strlcat(mouse->name, " ", sizeof(mouse->name));
-        strlcat(mouse->name, usbdev->product, sizeof(mouse->name));
-    }
-
-    if (!strlen(mouse->name)) {
-        snprintf(mouse->name, sizeof(mouse->name),
-                 "Gesture USB Mouse %04x:%04x",
-                 le16_to_cpu(usbdev->descriptor.idVendor),
-                 le16_to_cpu(usbdev->descriptor.idProduct));
-    } else {
-        strlcat(mouse->name, " [Gesture]", sizeof(mouse->name));
-    }
-
-    usb_make_path(usbdev, mouse->phys, sizeof(mouse->phys));
-    strlcat(mouse->phys, "/input0", sizeof(mouse->phys));
-
-    pr_info("gesture_mouse: Device name: %s\n", mouse->name);
-    pr_info("gesture_mouse: Physical path: %s\n", mouse->phys);
-    pr_info("gesture_mouse: Gesture detection: %s\n",
-            gesture_enabled ? "ENABLED" : "DISABLED");
-
-    /* Configure input device */
-    input_dev->name = mouse->name;
-    input_dev->phys = mouse->phys;
-    usb_to_input_id(usbdev, &input_dev->id);
-    input_dev->dev.parent = &intf->dev;
-
-    /* Set event types - include KEY events for keyboard shortcuts */
-    input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
-
-    /* Mouse buttons */
-    input_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
-        BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
-    input_dev->keybit[BIT_WORD(BTN_MOUSE)] |= BIT_MASK(BTN_SIDE) |
-        BIT_MASK(BTN_EXTRA);
-
-    /* Keyboard keys for gestures */
-    input_set_capability(input_dev, EV_KEY, KEY_LEFTCTRL);
-    input_set_capability(input_dev, EV_KEY, KEY_C);
-    input_set_capability(input_dev, EV_KEY, KEY_V);
-
-    /* Relative axes */
-    input_dev->relbit[0] = BIT_MASK(REL_X) | BIT_MASK(REL_Y) | BIT_MASK(REL_WHEEL);
-
-    input_set_drvdata(input_dev, mouse);
-    input_dev->open = gesture_mouse_open;
-    input_dev->close = gesture_mouse_close;
-
-    /* Initialize URB */
-    usb_fill_int_urb(mouse->irq, usbdev, pipe, mouse->data,
-                     (maxp > 8 ? 8 : maxp),
-                     gesture_mouse_irq, mouse, endpoint->bInterval);
-    mouse->irq->transfer_dma = mouse->data_dma;
-    mouse->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
-
-    /* Initialize gesture tracking */
-    reset_gesture_tracking(mouse);
-    memset(&mouse->stats, 0, sizeof(mouse->stats));
-
-    /* Register input device */
-    error = input_register_device(mouse->input_dev);
-    if (error) {
-        pr_err("gesture_mouse: Failed to register input device: %d\n", error);
-        goto fail_register;
-    }
-
-    usb_set_intfdata(intf, mouse);
-
-    pr_info("gesture_mouse: Probe successful!\n");
-    return 0;
-
-fail_register:
-    usb_free_urb(mouse->irq);
-fail_urb_alloc:
-    usb_free_coherent(usbdev, 8, mouse->data, mouse->data_dma);
-fail_dma_alloc:
-    input_free_device(input_dev);
-fail_input_alloc:
-    kfree(mouse);
-    return error;
-}
-
-/*
- * Disconnect function
- */
-static void gesture_mouse_disconnect(struct usb_interface *intf)
-{
-    struct gesture_usb_mouse *mouse = usb_get_intfdata(intf);
-
-    pr_info("gesture_mouse: Device disconnected\n");
-
-    usb_set_intfdata(intf, NULL);
-
-    if (mouse) {
-        pr_info("gesture_mouse: Final stats - C:%lu V:%lu Invalid:%lu\n",
-                mouse->stats.c_detected, mouse->stats.v_detected,
-                mouse->stats.invalid);
-
-        usb_kill_urb(mouse->irq);
-        input_unregister_device(mouse->input_dev);
-        usb_free_urb(mouse->irq);
-        usb_free_coherent(interface_to_usbdev(intf), 8,
-                          mouse->data, mouse->data_dma);
-        kfree(mouse);
-    }
-}
-
-/*
- * Device ID table - same as simple_usb_mouse
- */
-static const struct usb_device_id gesture_mouse_id_table[] = {
-    {
-        USB_INTERFACE_INFO(
-            USB_INTERFACE_CLASS_HID,
-            USB_INTERFACE_SUBCLASS_BOOT,
-            USB_INTERFACE_PROTOCOL_MOUSE
-        )
-    },
-    { }
-};
-
-MODULE_DEVICE_TABLE(usb, gesture_mouse_id_table);
-
-/*
- * USB Driver structure
- */
-static struct usb_driver gesture_mouse_driver = {
-    .name       = "gesture_usb_mouse",
-    .probe      = gesture_mouse_probe,
-    .disconnect = gesture_mouse_disconnect,
-    .id_table   = gesture_mouse_id_table,
-};
-
-module_usb_driver(gesture_mouse_driver);

wasd-emulator/Makefile

@@ -1,25 +0,0 @@
-
-.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

@@ -1,223 +0,0 @@
-
-#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");