Remap CaptionCall buttons into single input device with remapping

input_remap.c

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <linux/input.h>
#include <linux/uinput.h>
#include <errno.h>
#include <string.h>
#include <poll.h>
#include <time.h>

#define DEV_GPIO_KEYS "/dev/input/event0"
#define DEV_IMX_KEYPAD "/dev/input/event1"
#define DEV_ROTARY "/dev/input/event3"

#define KEY_ROTARY_LEFT KEY_LEFT
#define KEY_ROTARY_RIGHT KEY_RIGHT

struct input_event ev;
int uinput_fd;

// Rotary encoder tracking
int last_rotary_direction = 0;  // -1 for left, 1 for right, 0 for none
struct timespec last_rotary_time = {0, 0}; // Time of last rotary event
const int ROTARY_HOLD_TIME_MS = 150;  // Time threshold to consider "held"

// Get the current time in milliseconds
long get_time_ms() {
    struct timespec ts;
    clock_gettime(CLOCK_MONOTONIC, &ts);
    return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
}

// Sends key events (press/release)
void send_key_event(int key, int value) {
    struct input_event ev;
    memset(&ev, 0, sizeof(ev));
    ev.type = EV_KEY;
    ev.code = key;
    ev.value = value;
    write(uinput_fd, &ev, sizeof(ev));

    // Sync event
    ev.type = EV_SYN;
    ev.code = SYN_REPORT;
    ev.value = 0;
    write(uinput_fd, &ev, sizeof(ev));
}

// Releases the last rotary key if needed
void release_rotary_key() {
    if (last_rotary_direction != 0) {
        send_key_event(last_rotary_direction == 1 ? KEY_ROTARY_RIGHT : KEY_ROTARY_LEFT, 0);
        last_rotary_direction = 0;
    }
}

// Handles rotary encoder movement
void process_rotary_event(int direction) {
    long current_time = get_time_ms();
    long time_diff = current_time - (last_rotary_time.tv_sec * 1000 + last_rotary_time.tv_nsec / 1000000);

    // If changing direction, release the previous key
    if (direction != last_rotary_direction && last_rotary_direction != 0) {
        release_rotary_key();
    }

    // If a key is not already held, press it
    if (last_rotary_direction != direction || time_diff > ROTARY_HOLD_TIME_MS) {
        send_key_event(direction == 1 ? KEY_ROTARY_RIGHT : KEY_ROTARY_LEFT, 1);
    }

    // Update tracking
    last_rotary_direction = direction;
    clock_gettime(CLOCK_MONOTONIC, &last_rotary_time);
}

// Key remapping table
struct {
    int input_key;
    int output_key;
} key_map[] = {
    {KEY_NUMERIC_0, KEY_0},
    {KEY_NUMERIC_1, KEY_1},
    {KEY_NUMERIC_2, KEY_2},
    {KEY_NUMERIC_3, KEY_3},
    {KEY_NUMERIC_4, KEY_4},
    {KEY_NUMERIC_5, KEY_5},
    {KEY_NUMERIC_6, KEY_6},
    {KEY_NUMERIC_7, KEY_7},
    {KEY_NUMERIC_8, KEY_8},
    {KEY_NUMERIC_9, KEY_9},
    {KEY_NUMERIC_STAR, KEY_KPASTERISK},
    {KEY_NUMERIC_POUND, KEY_ENTER},
    {KEY_PROG1, KEY_SPACE},
    {KEY_PROG2, KEY_ESC},
    {KEY_PHONE, KEY_LEFTCTRL},
    {KEY_ROTARY_LEFT, KEY_LEFT},
    {KEY_ROTARY_RIGHT, KEY_RIGHT}
};

// Lookup function for remapping keys
int remap_key(int input_key) {
    int i;
    for (i = 0; i < sizeof(key_map)/sizeof(key_map[0]); i++) {
        if (key_map[i].input_key == input_key) {
            return key_map[i].output_key;
        }
    }
    return input_key;  // Return the same key if not found in mapping
}

void setup_uinput() {
    struct uinput_user_dev uidev;

    // Full list of all remapped keys
    int keys[] = {
        KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9,
        KEY_KPASTERISK, KEY_ENTER, KEY_SPACE, KEY_ESC, KEY_LEFTCTRL,
        KEY_LEFT, KEY_RIGHT
    };

    int i;  // C90 fix: Declare loop variable outside the for loop

    uinput_fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
    if (uinput_fd < 0) {
        perror("Failed to open /dev/uinput");
        exit(1);
    }

    // Enable event types
    ioctl(uinput_fd, UI_SET_EVBIT, EV_KEY);
    ioctl(uinput_fd, UI_SET_EVBIT, EV_REL);
    ioctl(uinput_fd, UI_SET_EVBIT, EV_SYN);

    // Register all required keys
    for (i = 0; i < sizeof(keys) / sizeof(keys[0]); i++) {  // C90 compatible loop
        ioctl(uinput_fd, UI_SET_KEYBIT, keys[i]);
    }

    // Configure the virtual device
    memset(&uidev, 0, sizeof(uidev));
    snprintf(uidev.name, UINPUT_MAX_NAME_SIZE, "Unified Input Device");
    uidev.id.bustype = BUS_USB;
    uidev.id.vendor = 0x1234;
    uidev.id.product = 0x5678;

    write(uinput_fd, &uidev, sizeof(uidev));
    ioctl(uinput_fd, UI_DEV_CREATE);
}

void process_event(int fd) {
    if (read(fd, &ev, sizeof(ev)) > 0) {
        if (ev.type == EV_KEY) {
            send_key_event(remap_key(ev.code), ev.value);
        } else if (ev.type == EV_REL && ev.code == REL_X) {
            if (ev.value > 0) {
                process_rotary_event(-1);  // Swap directions
            } else if (ev.value < 0) {
                process_rotary_event(1);   // Swap directions
            }
        }
    }
}

int main() {
    int fd_gpio = open(DEV_GPIO_KEYS, O_RDONLY);
    int fd_keypad = open(DEV_IMX_KEYPAD, O_RDONLY);
    int fd_rotary = open(DEV_ROTARY, O_RDONLY);
    struct pollfd fds[4];

    if (fd_gpio < 0 || fd_keypad < 0 || fd_rotary < 0) {
        perror("Failed to open input devices");
        return 1;
    }

    setup_uinput();

    fds[0].fd = fd_gpio;
    fds[1].fd = fd_keypad;
    fds[2].fd = fd_rotary;
    fds[0].events = fds[1].events = fds[2].events = fds[3].events = POLLIN;

    while (1) {
        int poll_ret = poll(fds, 4, 50); // Poll every 50ms

        if (poll_ret > 0) {
            if (fds[0].revents & POLLIN) process_event(fd_gpio);
            if (fds[1].revents & POLLIN) process_event(fd_keypad);
            if (fds[2].revents & POLLIN) process_event(fd_rotary);
        }

        // Check if it's time to release the rotary key
        long current_time = get_time_ms();
        long last_time = last_rotary_time.tv_sec * 1000 + last_rotary_time.tv_nsec / 1000000;

        if (last_rotary_direction != 0 && (current_time - last_time) > ROTARY_HOLD_TIME_MS) {
            release_rotary_key();
        }
    }

    close(fd_gpio);
    close(fd_keypad);
    close(fd_rotary);
    ioctl(uinput_fd, UI_DEV_DESTROY);
    close(uinput_fd);
    return 0;
}

xorg.conf

Section "Device"
        Identifier              "BonanzaLCD"
        Driver                  "fbdev"
        Option                  "fbdev" "/dev/fb0"
EndSection

Section "InputDevice"
        Identifier              "BonanzaTS"
        Driver                  "evdev"
        Option                  "Device" "/dev/input/event2"
        Option                  "SendCoreEvents" "yes"
EndSection

Section "InputDevice"
        Identifier  "UnifiedInput"
        Driver      "evdev"
        Option      "Device" "/dev/input/event5"
        Option      "AutoServerLayout" "true"
EndSection

Section "Monitor"
        Identifier              "BonanzaMonitor"
        VendorName              "CaptionCall"
        ModelName               "Bonanza"
        Mode "1024x600"
                # D: 64.998 MHz, H: 48.362 kHz, V: 75.802 Hz
                DotClock        64.999
                HTimings        1024 1064 1124 1344
                VTimings        600 607 617 638
                Flags           "-HSync" "-VSync"
        EndMode
EndSection

Section "Screen"
        Identifier              "Screen0"
        Device                  "BonanzaLCD"
        Monitor                 "BonanzaMonitor"
        DefaultDepth            16
        SubSection              "Display"
                Depth           16
                Modes           "1024x600"
        EndSubSection
EndSection

Section "ServerLayout"
        Identifier              "Layout0"
        Screen                  "Screen0"
        InputDevice             "BonanzaTS" "CorePoinrter"
        InputDevice "UnifiedInput" "CoreKeyboard"
EndSection
 
Section "ServerFlags"
        Option                  "AllowEmptyInput" "false"
        Option                  "AutoAddDevices" "false"
        Option                  "AutoEnableDevices" "false"
EndSection