copilot2ctrl.c

// SPDX-License-Identifier: GPL-2.0-or-later

// #define DEBUG

#include <linux/init.h>
#include <linux/input-event-codes.h>
#include <linux/input.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/printk.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>

#define KEY_RELEASE 0
#define KEY_PRESS 1
#define KEY_REPEAT 2

#define QUEUE_SIZE 16

// 仮想キーボード経由で入力するキーイベント
struct event {
  unsigned int type;
  unsigned int code;
  int value;
};

// 仮想キーボード経由で入力するキーイベントを管理するための構造体
struct eventlog {
  spinlock_t lock;
  // 入力すべきイベントをバッファできるようにしておく
  struct event ring[QUEUE_SIZE];
  int head;
  int tail;
  int size;
  bool full;

  int state_leftmeta;
  int state_leftshift;
};

static struct eventlog *evlog;

// モジュールをロードしてすぐの入力かどうかの判定用
static bool the_very_first = true;

// 仮想キーボード
static struct input_dev *vkbd;

// 仮想キーボード登録状態の確認用
static bool vkbd_registered = false;

// 仮想キーボード登録用
static struct work_struct register_work;

// 仮想キーボード登録時にデッドロックしないようにworkqueue経由で登録する
static void register_vkbd_work_func(struct work_struct *work) {
  int error;
  if (!vkbd) {
    return;
  }

  error = input_register_device(vkbd);
  if (error) {
    input_free_device(vkbd);
    vkbd = NULL;
    return;
  }

  vkbd_registered = true;
}

// イベントをキューに入れる
static void enqueue(unsigned int type, unsigned int code, int value) {
  unsigned long flags;
  spin_lock_irqsave(&evlog->lock, flags);

  struct event e = {
      .type = type,
      .code = code,
      .value = value,
  };
  evlog->ring[evlog->tail] = e;
  evlog->tail = (evlog->tail + 1) % QUEUE_SIZE;
  if (evlog->full) {
    evlog->head = (evlog->head + 1) % QUEUE_SIZE;
  } else {
    evlog->full = evlog->head == evlog->tail;
    evlog->size++;
  }

  spin_unlock_irqrestore(&evlog->lock, flags);
}

// イベントをキューから出す
static bool dequeue(struct event *dst) {
  unsigned long flags;
  spin_lock_irqsave(&evlog->lock, flags);

  if (evlog->full == false && evlog->head == evlog->tail) {
    spin_unlock_irqrestore(&evlog->lock, flags);
    return false;
  }

  // 書き込み先がなければ空読み
  if (dst != NULL) {
    *dst = evlog->ring[evlog->head];
  }

  evlog->head = (evlog->head + 1) % QUEUE_SIZE;
  evlog->full = false;
  evlog->size--;

  spin_unlock_irqrestore(&evlog->lock, flags);
  return true;
}

static int record_state(unsigned int code, int value) {
  /*
    0 1 OK
    1 0 OK
    1 2 OK
    2 0 OK
    2 2 OK

    0 0 NG
    0 2 NG
    1 1 NG
    2 1 NG
   */

  int value_should_be = value;

  // 状態遷移が不正ならスキップ
  if (code == KEY_LEFTMETA || code == KEY_LEFTSHIFT) {
    int state =
        code == KEY_LEFTMETA ? evlog->state_leftmeta : evlog->state_leftshift;

    if (state == KEY_RELEASE && value == KEY_RELEASE) {
      value_should_be = -1;
    } else if (state == KEY_RELEASE && value == KEY_REPEAT) {
      value_should_be = KEY_PRESS;
    } else if (state == KEY_PRESS && value == KEY_PRESS) {
      value_should_be = KEY_REPEAT;
    } else if (state == KEY_REPEAT && value == KEY_PRESS) {
      value_should_be = KEY_REPEAT;
    }
  }

  // 状態遷移を記録
  if (value_should_be >= 0) {
    if (code == KEY_LEFTMETA) {
      evlog->state_leftmeta = value_should_be;
    } else if (code == KEY_LEFTSHIFT) {
      evlog->state_leftshift = value_should_be;
    }
  } else {
    pr_debug("copilot2ctrl: [debug] ignored code=%d, value=%d because of "
             "invalid state change\n",
             code, value);
  }

  return value_should_be;
}

static void copilot2ctrl_flush(int count) {
  // キーボードの準備ができていなければ何もしない
  if (!vkbd || !vkbd_registered) {
    return;
  }

  // キューに入っているイベントをすべて消化する
  struct event e;
  for (int i = 0; i < count; i++) {
    if (dequeue(&e)) {
      int value_should_be = record_state(e.code, e.value);
      if (value_should_be >= 0) {
        pr_debug(
            "copilot2ctrl: input via virtual keyboard: code=%d, value=%d\n",
            e.code, value_should_be);
        input_report_key(vkbd, e.code, value_should_be);
        input_sync(vkbd);
      }
    }
  }
}

static bool copilot2ctrl_filter(struct input_handle *handle, unsigned int type,
                                unsigned int code, int value) {
  if (type != EV_KEY) {
    return false;
  }

  // モジュールを読み込んですぐのキーリリースは元のキーボードからのイベントとして扱う
  if (the_very_first) {
    if (value == KEY_RELEASE) {
      return false;
    }
    the_very_first = false;
  }

  /*
    Copilotキーの入力は、次のシーケンスで入力される

    KEY_LEFTMETA  KEY_PRESS
    KEY_LEFTSHIFT KEY_PRESS
    KEY_F23       KEY_PRESS

    KEY_LEFTMETA  KEY_REPEAT
    KEY_LEFTSHIFT KEY_REPEAT
    KEY_F23       KEY_REPEAT

    KEY_F23       KEY_RELEASE
    KEY_LEFTSHIFT KEY_RELEASE
    KEY_LEFTMETA  KEY_RELEASE
   */

  if (evlog->size == 0) {
    // 1文字目の入力
    if (code == KEY_LEFTMETA && (value == KEY_PRESS || value == KEY_REPEAT)) {
      // KEY_LEFTMETAが押されたか、リピートされた
      enqueue(type, code, value);
    } else if (code == KEY_F23 && value == KEY_RELEASE) {
      // KEY_F23がリリースされた
      enqueue(type, code, value);
      // タイミングによっては後続のLEFTSHIFTとLEFTMETAがリリースされないケースがある
      enqueue(type, KEY_LEFTSHIFT, KEY_RELEASE);
      enqueue(type, KEY_LEFTMETA, KEY_RELEASE);

      // TODO: ここでキー押下中のキーをすべてリリースする

    } else {
      // Copilotキーとは関係ない場合もひとまずキューに入れる
      enqueue(type, code, value);
    }
  } else {
    // 2文字目以降の入力
    // シーケンスが続いているかもしれないので一旦キューに入れて順序を保つ
    enqueue(type, code, value);
  }

  // キューの中を確認する
  unsigned long flags;
  spin_lock_irqsave(&evlog->lock, flags);
  // サイズを取得
  int size = evlog->size;
  // 先頭のシーケンス3つを取得
  struct event e0 = evlog->ring[evlog->head];
  struct event e1 = evlog->ring[(evlog->head + 1) % QUEUE_SIZE];
  struct event e2 = evlog->ring[(evlog->head + 2) % QUEUE_SIZE];
  spin_unlock_irqrestore(&evlog->lock, flags);

  if (e0.code == KEY_LEFTMETA && e0.value != KEY_RELEASE) {
    if (size >= 2) {
      if (e1.code == KEY_LEFTSHIFT && e1.value != KEY_RELEASE) {
        if (size >= 3) {
          if (e2.code == KEY_F23 && e2.value != KEY_RELEASE) {
            // CopilotキーのKEY_PRESSまたはKEY_REPEAT
            // 先頭の2つのシーケンスを削除
            dequeue(NULL); // drop e0: KEY_LEFTMETA
            dequeue(NULL); // drop e1: KEY_LEFTSHIFT
            // キーコードを右Ctrlに変更
            evlog->ring[evlog->head].code = KEY_RIGHTCTRL;
            // 仮想キーボードに流し込む
            copilot2ctrl_flush(3);
          } else {
            // 不適合
            copilot2ctrl_flush(3);
          }
        } else {
          // 保留
        }
      } else {
        // 不適合
        copilot2ctrl_flush(2);
      }
    } else {
      // 保留
    }
  } else if (e0.code == KEY_F23 && e0.value == KEY_RELEASE) {
    if (size >= 2) {
      if (e1.code == KEY_LEFTSHIFT && e1.value == KEY_RELEASE) {
        if (size >= 3) {
          if (e2.code == KEY_LEFTMETA && e2.value == KEY_RELEASE) {
            // CopilotキーのKEY_RELEASE
            dequeue(NULL); // drop e0: KEY_F23
            dequeue(NULL); // drop e1: KEY_LEFTSHIFT
            // キーコードを右Ctrlに変更
            evlog->ring[evlog->head].code = KEY_RIGHTCTRL;
            // 送信
            copilot2ctrl_flush(3);
          } else {
            // 不適合
            copilot2ctrl_flush(3);
          }
        } else {
          // 保留
        }
      } else {
        // 不適合
        copilot2ctrl_flush(2);
      }
    } else {
      // 保留
    }
  } else {
    // 不適合
    copilot2ctrl_flush(1);
  }

  return true;
}

static int copilot2ctrl_connect(struct input_handler *handler,
                                struct input_dev *dev,
                                const struct input_device_id *id) {
  struct input_handle *handle;
  int error;

  // 自分で用意した仮想キーボードは対象外
  if (dev == vkbd) {
    return -ENODEV;
  }

  // キーボードを対象とする
  if (!test_bit(KEY_A, dev->keybit)) {
    return -ENODEV;
  }

  // handle初期化
  handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
  if (!handle) {
    return -ENOMEM;
  }
  handle->dev = dev;
  handle->handler = handler;
  handle->name = "copilot2ctrl_handle";

  // 仮想キーボードの初期化
  if (!vkbd) {
    vkbd = input_allocate_device();
    if (!vkbd) {
      error = -ENOMEM;
      goto err_free_handle;
    }

    vkbd->name = "copilot2ctrl virtual keyboard";
    vkbd->id.bustype = BUS_VIRTUAL;
    vkbd->id.vendor = 0x0001;
    vkbd->id.product = 0x0001;
    vkbd->id.version = 0x0100;

    set_bit(EV_KEY, vkbd->evbit);
    unsigned long i;
    for_each_set_bit(i, dev->keybit, KEY_CNT) { set_bit(i, vkbd->keybit); }

    set_bit(EV_KEY, vkbd->evbit);
    set_bit(KEY_RIGHTCTRL, vkbd->keybit);

    schedule_work(&register_work);
  }

  // handle登録
  error = input_register_handle(handle);
  if (error)
    goto err_free_handle;

  // デバイスをオープン
  error = input_open_device(handle);
  if (error)
    goto err_unregister_handle;

  pr_info("copilot2ctrl: connected\n");

  return 0;

err_unregister_handle:
  input_unregister_handle(handle);
err_free_handle:
  kfree(handle);
  return error;
}

static void copilot2ctrl_disconnect(struct input_handle *handle) {
  pr_info("copilot2ctrl: disconnecting\n");
  // 後始末
  input_close_device(handle);
  input_unregister_handle(handle);
  kfree(handle);
}

static const struct input_device_id copilot2ctrl_ids[] = {
    {
        .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
        .evbit = {[BIT_WORD(EV_KEY)] = BIT_MASK(EV_KEY)},
    },
    {},
};
MODULE_DEVICE_TABLE(input, copilot2ctrl_ids);

static struct input_handler copilot2ctrl_handler = {
    .filter = copilot2ctrl_filter,
    .connect = copilot2ctrl_connect,
    .disconnect = copilot2ctrl_disconnect,
    .name = "copilot2ctrl",
    .id_table = copilot2ctrl_ids,
};

static int __init copilot2ctrl_init(void) {
  int error;

  // evlogの初期化
  evlog = kzalloc(sizeof(struct eventlog), GFP_KERNEL);
  if (!evlog) {
    return -ENOMEM;
  }

  // ロックの初期化
  spin_lock_init(&evlog->lock);

  // workqueueの初期化
  INIT_WORK(&register_work, register_vkbd_work_func);

  error = input_register_handler(&copilot2ctrl_handler);
  if (error) {
    pr_warn("copilot2ctrl: failed to load module\n");
    kfree(evlog);
    return error;
  }
  pr_info("copilot2ctrl: module loaded\n");
  return 0;
}

static void __exit copilot2ctrl_exit(void) {
  // 仮想キーボードの登録をキャンセル
  cancel_work_sync(&register_work);

  // ハンドラ登録解除
  input_unregister_handler(&copilot2ctrl_handler);

  // 仮想キーボードの登録解除
  if (vkbd) {
    if (vkbd_registered) {
      input_unregister_device(vkbd);
    } else {
      input_free_device(vkbd);
    }
    vkbd = NULL;
  }

  // 仮想キーボード経由のキー入力をキャンセル
  if (evlog) {
    kfree(evlog);
    evlog = NULL;
  }

  pr_info("copilot2ctrl: module unloaded\n");
  return;
}

module_init(copilot2ctrl_init);
module_exit(copilot2ctrl_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Takuma Nakajima");
MODULE_DESCRIPTION("Remap copilot key to right control key");