Maximize force feedback

separate 3 modes: media, WASD, mouse

README.md

@@ -1,5 +1,6 @@
-# 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).
 
@@ -9,7 +10,6 @@ A helper tool (``usb_driver_manager.py``) is included to make it easier to:
 - unbind/bind a selected interface to a chosen driver during development
 
 ## Drivers
-----------
 
 ### Mouse driver (``mouse/``)
 USB HID boot-protocol mouse driver.
@@ -37,7 +37,6 @@ make
 After building, the module (``*.ko``) is typically placed under ``build/`` by the provided Makefiles.
 
 ## USB Driver Manager
----------------------
 
 **Usage examples:**
 ```bash
@@ -55,7 +54,7 @@ sudo python3 usb_driver_manager.py ./mouse/build ./g29_media_usb/build
 4. Confirm; the tool unbinds the current driver, reloads the module if needed, and binds the chosen interface.
 
 ## Testing
-----------
+
 After binding the driver, use ``evtest`` to confirm key events:
 ```bash
 sudo evtest

g29-wheel/g29_usb.c

@@ -25,302 +25,554 @@
 #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");
 
-#define USB_VENDOR_ID_LOGITECH      0x046d
-#define USB_DEVICE_ID_LOGITECH_G29  0xc24f
-#define USB_DEVICE_ID_LOGITECH_G29_ALT 0xc260
-
-#define G29_BTN_PLUS        0x00800000u
-#define G29_BTN_MINUS       0x01000000u
-#define G29_BTN_RED_CW      0x02000000u
-#define G29_BTN_RED_CCW     0x04000000u
-#define G29_BTN_RETURN      0x08000000u
-#define G29_BTN_R1          0x00000100u
-#define G29_BTN_L1          0x00000200u
-
 enum g29_mode {
-	G29_MODE_MEDIA = 0,
+    G29_MODE_MEDIA = 0,
+    G29_MODE_WASD = 1,
+    G29_MODE_MOUSE = 2,
 };
 
 static int mode = G29_MODE_MEDIA;
-module_param(mode, int, 0444);
-MODULE_PARM_DESC(mode, "Mapping mode (0=MEDIA)");
+module_param(mode, int, 0644);
+MODULE_PARM_DESC(mode, "Initial mode (0=MEDIA, 1=WASD, 2=MOUSE)");
 
-struct g29_state {
-	u32 buttons_le;
-	u16 rot_le;
-	u8 gas;
-	u8 brk;
-	u8 clt;
-	u8 gr_x;
-	u8 gr_y;
-	u8 gr_z;
+static int steer_deadzone = 10;
+module_param(steer_deadzone, int, 0644);
+MODULE_PARM_DESC(steer_deadzone, "Steering deadzone radius from center (default=10)");
+
+#define NORMALIZATION_PRECISION 1000
+
+struct g29_keymap {
+    u32 mask;
+    unsigned short keycode;
 };
 
-struct g29_keymap_edge {
-	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_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 },
+static const struct g29_keymap mouse_mode_keymap[] = {
+    {G29_BTN_L1, BTN_LEFT},
+    {G29_BTN_R1, BTN_RIGHT},
+    {G29_BTN_RETURN, BTN_MIDDLE},
 };
 
 struct g29_dev {
-	char name[128];
-	char phys[64];
+    char name[128];
+    char phys[64];
 
-	struct usb_device *udev;
-	struct input_dev *input;
+    struct usb_device *udev;
+	struct usb_interface *intf;
+    struct input_dev *input;
 
-	struct urb *urb;
-	u8 *buf;
-	dma_addr_t buf_dma;
-	int maxp;
-	int interval;
-	int endpoint;
+    struct urb *urb;
+    u8 *buf;
+    dma_addr_t buf_dma;
+    int maxp;
+    int interval;
+    int endpoint;
 
-	struct timer_list steer_timer;
-	u32 steer_phase_ms;
+    struct timer_list steer_timer;
+    struct timer_list mouse_timer;
+    u32 steer_phase_ms;
 
-	struct g29_state last;
+    u32 phase_accumulator;
+    u32 gas_phase_accumulator;
+    u32 clutch_phase_accumulator;
+
+    struct work_struct autocenter_work;
+    int out_ep_addr;
+    int out_ep_maxp;
+    int out_ep_interval;
+
+    enum g29_mode current_mode;
+    struct g29_state last;
 };
 
 
-static void g29_steer_timer_fn(struct timer_list *t) {
-	struct g29_dev *g29 = timer_container_of(g29, t, steer_timer);
+static void g29_find_int_out_ep(struct g29_dev *g29) {
+    const struct usb_host_interface *alts = g29->intf->cur_altsetting;
 
-	const int rot = le16_to_cpu(g29->last.rot_le);
+    g29->out_ep_addr = 0;
+    g29->out_ep_maxp = 0;
+    g29->out_ep_interval = 0;
+    for (int i = 0; i < alts->desc.bNumEndpoints; i++) {
+        const struct usb_endpoint_descriptor *d = &alts->endpoint[i].desc;
+        if (!usb_endpoint_is_int_out(d))
+            continue;
+        g29->out_ep_addr = d->bEndpointAddress;
+        g29->out_ep_maxp = usb_endpoint_maxp(d);
+        g29->out_ep_interval = d->bInterval;
+        dev_info(&g29->intf->dev, "Found interrupt OUT ep=%02x maxp=%d interval=%d\n", g29->out_ep_addr, g29->out_ep_maxp, g29->out_ep_interval);
+        return;
+    }
 
-	input_report_key(g29->input, KEY_W, g29->last.gas <= 0x80);
-	input_report_key(g29->input, KEY_S, g29->last.clt <= 0x80);
-	input_report_key(g29->input, KEY_A, rot <= 0x6000);
-	input_report_key(g29->input, KEY_D, rot >= 0xA000);
-
-	mod_timer(&g29->steer_timer, jiffies + msecs_to_jiffies(2));
+    dev_info(&g29->intf->dev, "No interrupt OUT endpoint found on this interface (will use SET_REPORT)\n");
 }
 
-static void g29_apply_media_mode(struct g29_dev *g29, const struct g29_state *cur, const struct g29_state *prev) {
-	u32 pressed = le32_to_cpu(cur->buttons_le & ~prev->buttons_le);
-	for (int i = 0; i < ARRAY_SIZE(g29_media_edge_map); i++) {
-		const struct g29_keymap_edge *e = &g29_media_edge_map[i];
-		if (pressed & e->mask) {
-			input_report_key(g29->input, e->keycode, 1);
-			input_report_key(g29->input, e->keycode, 0);
-		}
-	}
+static int g29_send_interrupt_out(struct g29_dev *g29, const u8 *buf, int len) {
+    int ret, actual = 0;
 
-	input_sync(g29->input);
+    if (!g29->out_ep_addr)
+        return -ENODEV;
+
+    ret = usb_interrupt_msg(g29->udev,
+                            usb_sndintpipe(g29->udev, g29->out_ep_addr),
+                            (void *) buf, len, &actual, 1000);
+    if (ret < 0)
+        return ret;
+    if (actual != len)
+        return -EIO;
+    return 0;
 }
 
-static void g29_process_report(struct g29_dev *g29, const u8 *data, unsigned int len) {
-	if (len < 12) return;
+static int g29_send_set_report(const struct g29_dev *g29, const int ifnum, const int report_id, const u8 *buf, const int len) {
+    const u16 wValue = ((u16) 0x02 << 8) | (report_id & 0xff);
+    const int ret = usb_control_msg(g29->udev, usb_sndctrlpipe(g29->udev, 0), 0x09,
+        USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
+        wValue, ifnum, (void *) buf, len, USB_CTRL_SET_TIMEOUT);
+    if (ret < 0)
+        return ret;
+    if (ret != len)
+        return -EIO;
+    return 0;
+}
 
-	struct g29_state *cur = (void *) data;
-	switch (mode) {
-	case G29_MODE_MEDIA:
-	default:
-		g29_apply_media_mode(g29, cur, &g29->last);
-		break;
-	}
+static int g29_send_cmd7(struct g29_dev *g29, const u8 cmd0, const u8 cmd1, const u8 cmd2, const u8 cmd3, const u8 cmd4, const u8 cmd5, const u8 cmd6) {
+    const u8 cmd[] = {cmd0, cmd1, cmd2, cmd3, cmd4, cmd5, cmd6};
+    int ret;
+    if ((ret = g29_send_interrupt_out(g29, cmd, 7)) == 0)
+        return 0;
 
-	g29->last = *cur;
+    const int ifnum = 0, report_id = 0;
+    if ((ret = g29_send_set_report(g29, ifnum, report_id, cmd, 7)) < 0) {
+        dev_warn(&g29->intf->dev,
+                 "autocenter cmd %02x %02x %02x %02x %02x %02x %02x failed: %d (ifnum=%d report_id=%d out_ep=%02x)\n",
+                 cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6],
+                 ret, ifnum, report_id, g29->out_ep_addr);
+    }
+    return ret;
+}
+
+static void g29_set_autocenter_default(struct g29_dev *g29, const u16 magnitude) {
+    if (magnitude == 0) {
+        g29_send_cmd7(g29, 0xf5, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+        return;
+    }
+
+    u32 expand_a, expand_b;
+    if (magnitude <= 0xaaaa) {
+        expand_a = 0x0c * magnitude;
+        expand_b = 0x80 * magnitude;
+    } else {
+        expand_a = (0x0c * 0xaaaa) + 0x06 * (magnitude - 0xaaaa);
+        expand_b = (0x80 * 0xaaaa) + 0xff * (magnitude - 0xaaaa);
+    }
+    expand_a >>= 1;
+
+    if (g29_send_cmd7(g29, 0xfe, 0x0d, expand_a / 0xaaaa, expand_a / 0xaaaa, expand_b / 0xaaaa, 0x00, 0x00) < 0)
+        return;
+
+    g29_send_cmd7(g29, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00);
+}
+
+static void g29_autocenter_work_fn(struct work_struct *work) {
+    struct g29_dev *g29 = container_of(work, struct g29_dev, autocenter_work);
+    const u16 mag = 0xFFFF;
+    if (mag == 0)
+        return;
+
+    g29_set_autocenter_default(g29, mag);
+}
+
+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(1));
+    }
+    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 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);
+    const int up = G29_PEDAL_RELEASED - g29->last.gas;
+    const int down = G29_PEDAL_RELEASED - g29->last.clt;
+    const int left = rot < 0x8000 ? WHEEL_CENTER - rot : 0;
+    const int right = rot > 0x8000 ? rot - WHEEL_CENTER : 0;
+
+    const int dx = (right - left) / 0x400;
+    const int dy = (down - up) / 0x20;
+
+    if (dx != 0 || dy != 0) {
+        input_report_rel(g29->input, REL_X, dx);
+        input_report_rel(g29->input, REL_Y, dy);
+        input_sync(g29->input);
+    }
+
+    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 period = 50;
+    const int rot = le16_to_cpu(g29->last.rot_le);
+    const int gas = G29_PEDAL_RELEASED - g29->last.gas;
+    const int brk = G29_PEDAL_RELEASED - g29->last.brk;
+
+    const int gas_duty = gas * period / 0x40;
+    input_report_key(g29->input, KEY_W, g29->gas_phase_accumulator < gas_duty);
+    g29->gas_phase_accumulator++;
+    g29->gas_phase_accumulator %= period;
+
+    input_report_key(g29->input, KEY_S, brk >= G29_PEDAL_THRESHOLD);
+
+    if (rot >= 0x7ff8 && rot <= 0x8008) {
+        input_report_key(g29->input, KEY_A, 0);
+        input_report_key(g29->input, KEY_D, 0);
+    } else {
+        const int mag = rot < WHEEL_CENTER ? WHEEL_CENTER - rot : rot - WHEEL_CENTER;
+        const int duty = mag * period / 0x3000;
+        const int k1 = rot > WHEEL_CENTER ? KEY_D : KEY_A;
+        const int k2 = rot > WHEEL_CENTER ? KEY_A : KEY_D;
+        input_report_key(g29->input, k2, 0);
+        input_report_key(g29->input, k1, g29->phase_accumulator < duty);
+    }
+
+    g29->phase_accumulator++;
+    g29->phase_accumulator %= period;
+
+    input_sync(g29->input);
+
+    if (g29->current_mode == G29_MODE_WASD)
+        mod_timer(&g29->steer_timer, jiffies + msecs_to_jiffies(1));
+}
+
+static void process_media_mode(const struct g29_dev *g29, const struct g29_state *cur, const struct g29_state *prev) {
+    const u32 buttons = le32_to_cpu(cur->buttons_le);
+    for (int i = 0; i < ARRAY_SIZE(media_mode_keymap); i++) {
+        const struct g29_keymap *k = &media_mode_keymap[i];
+        input_report_key(g29->input, k->keycode, !!(buttons & k->mask));
+    }
+    input_sync(g29->input);
+}
+
+static void process_wasd_mode(const 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)
+    const u32 buttons = le32_to_cpu(cur->buttons_le);
+
+    input_report_key(g29->input, KEY_C, !!(buttons & G29_BTN_L1));
+    input_report_key(g29->input, KEY_SPACE, !!(buttons & G29_BTN_R1));
+    input_report_key(g29->input, KEY_ENTER, !!(buttons & G29_BTN_RETURN));
+    input_report_key(g29->input, KEY_M, !!(buttons & G29_BTN_CIRCLE));
+
+    if (buttons & G29_BTN_RED_CW) {
+        input_report_rel(g29->input, REL_WHEEL, 1);
+    } else if (buttons & G29_BTN_RED_CCW) {
+        input_report_rel(g29->input, REL_WHEEL, -1);
+    } else {
+        input_report_rel(g29->input, REL_WHEEL, 0);
+    }
+
+    input_sync(g29->input);
+}
+
+static void process_mouse_mode(const struct g29_dev *g29, const struct g29_state *cur, const struct g29_state *prev) {
+    const u32 buttons = le32_to_cpu(cur->buttons_le);
+    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];
+        input_report_key(g29->input, k->keycode, !!(buttons & k->mask));
+    }
+
+    if (pressed & G29_BTN_RED_CW) {
+        input_report_rel(g29->input, REL_WHEEL, 1);
+    } else if (pressed & G29_BTN_RED_CCW) {
+        input_report_rel(g29->input, REL_WHEEL, -1);
+    } else {
+        input_report_rel(g29->input, REL_WHEEL, 0);
+    }
+
+    input_sync(g29->input);
+}
+
+static void g29_check_mode_switch(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);
+    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) {
+        g29_switch_mode(g29, G29_MODE_MOUSE);
+    }
+}
+
+static void g29_process_report(struct g29_dev *g29, const u8 *data, const unsigned int len) {
+    if (len < 12) return;
+    const 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;
+    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 */
-	}
+    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);
+    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);
+    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);
+    struct g29_dev *g29 = input_get_drvdata(input);
 
-	g29->urb->dev = g29->udev;
-	if (usb_submit_urb(g29->urb, GFP_KERNEL))
-		return -EIO;
+    g29->urb->dev = g29->udev;
+    if (usb_submit_urb(g29->urb, GFP_KERNEL))
+        return -EIO;
 
-	mod_timer(&g29->steer_timer, jiffies + msecs_to_jiffies(2));
+    g29_switch_mode(g29, mode);
+    schedule_work(&g29->autocenter_work);
 
-	return 0;
+    return 0;
 }
 
 static void g29_input_close(struct input_dev *input) {
-	struct g29_dev *g29 = input_get_drvdata(input);
-	timer_delete_sync(&g29->steer_timer);
-	usb_kill_urb(g29->urb);
+    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);
+
+    cancel_work_sync(&g29->autocenter_work);
+    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;
+    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;
+    /* 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 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;
-	}
+    struct input_dev *input;
+    if ((input = input_allocate_device()) == NULL) {
+        ret = -ENOMEM;
+        goto err_free_g29;
+    }
 
-	g29->udev = udev;
-	g29->input = input;
+    g29->udev = udev;
+    g29->intf = intf;
+    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->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, g29_steer_timer_fn, 0);
+    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->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 ((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));
+    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));
+    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;
+    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);
+    g29_find_int_out_ep(g29);
+    INIT_WORK(&g29->autocenter_work, g29_autocenter_work_fn);
 
-	/* 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);
+    __set_bit(EV_KEY, input->evbit);
+    __set_bit(EV_REL, input->evbit);
 
-	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);
+    // 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);
 
-	input_set_drvdata(input, g29);
-	input->open = g29_input_open;
-	input->close = g29_input_close;
+    // 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);
+    input_set_capability(input, EV_KEY, KEY_C);
+    input_set_capability(input, EV_KEY, KEY_SPACE);
+    input_set_capability(input, EV_KEY, KEY_ENTER);
+    input_set_capability(input, EV_KEY, KEY_M);
 
-	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;
+    // 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);
 
-	if ((ret = input_register_device(input)) != 0) {
-		goto err_free_urb;
-	}
+    input_set_drvdata(input, g29);
+    input->open = g29_input_open;
+    input->close = g29_input_close;
 
-	usb_set_intfdata(intf, g29);
+    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;
 
-	dev_info(&intf->dev,
-		 "G29 media driver bound (ep=%02x interval=%u)\n",
-		 ep->bEndpointAddress, ep->bInterval);
+    if ((ret = input_register_device(input)) != 0) {
+        goto err_free_urb;
+    }
 
-	return 0;
+    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);
+    usb_free_urb(g29->urb);
 err_free_buf:
-	usb_free_coherent(udev, g29->maxp, g29->buf, g29->buf_dma);
+    usb_free_coherent(udev, g29->maxp, g29->buf, g29->buf_dma);
 err_free_input:
-	input_free_device(input);
+    input_free_device(input);
 err_free_g29:
-	kfree(g29);
-	return ret;
+    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");
+    struct g29_dev *g29 = usb_get_intfdata(intf);
+    usb_set_intfdata(intf, NULL);
+    if (!g29) return;
+    timer_delete_sync(&g29->steer_timer);
+    cancel_work_sync(&g29->autocenter_work);
+    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) },
-	{ }
+    {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,
+    .name = "g29_usb",
+    .id_table = g29_id_table,
+    .probe = g29_probe,
+    .disconnect = g29_disconnect,
 };
 
 module_usb_driver(g29_driver);

g29-wheel/g29_usb.h

@@ -0,0 +1,75 @@
+/*
+ * 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         0x10000000u
+
+#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        0x8000
+
+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

logitech-G29.md

@@ -45,7 +45,8 @@ Logitech G29 USB Protocol
     - `0x02000000` - Red rotation clockwise
     - `0x04000000` - Red rotation counterclockwise
     - `0x08000000` - Return
-    - `0xF0000000` - ?
+    - `0x10000000` - PS3 Logo
+    - `0xE0000000` - ?
 - `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).

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