key actions implementation

config/base.toml

@@ -1,6 +1,7 @@
 source = [
 	'protocol/protocol.c',
 	'driver/pixart/pixart_pmw.c',
+	'key_actions/key_actions.c',
 ]
 c_flags = [
 	'-fdiagnostics-color',

config/families/efm32gg12b.toml

@@ -37,6 +37,8 @@ source = [
 	'usb.c',
 	'usb_descriptors.c',
 	'hal/hid.c',
+	'driver/key_direct.c',
+	'driver/key_matrix.c',
 ]
 
 [dependencies]

src/key_actions/key_actions.c

@@ -0,0 +1,75 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: 2021 Rafael Silva <perigoso@riseup.net>
+ */
+
+#include "key_actions/key_actions.h"
+#include "util/data.h"
+
+struct key_actions_return_t key_actions_update(struct key_actions_config_t config)
+{
+	u8 keycode_index = 0;
+	struct key_actions_return_t return_data = {};
+
+	for (size_t i = 0; i < config.key_list_size; i++) {
+		switch (config.active_layer[i].node_action) {
+			case layer_node_none:
+				break;
+
+			case layer_node_regular:
+				if (config.key_list[i]->key_status == key_pressed) {
+					if (keycode_index < 6)
+						return_data.keycodes[keycode_index++] = config.active_layer[i].data[0];
+					return_data.data_present = 1;
+				}
+				break;
+
+			case layer_node_tap_hold:
+				if (config.key_list[i]->key_status == key_pressed) {
+					if (config.key_list[i]->key_t_delta > config.tap_interval) {
+						config.active_layer[i].data[3] = 0;
+						if (keycode_index < 6)
+							return_data.keycodes[keycode_index++] = config.active_layer[i].data[1];
+						return_data.data_present = 1;
+					} else {
+						config.active_layer[i].data[3] = 1;
+					}
+				} else {
+					if (config.active_layer[i].data[3]) {
+						config.active_layer[i].data[3] = 0;
+						if (keycode_index < 6)
+							return_data.keycodes[keycode_index++] = config.active_layer[i].data[0];
+						return_data.data_present = 1;
+					}
+				}
+
+				break;
+
+			case layer_node_set_layer:
+				if (config.key_list[i]->key_status == key_pressed) {
+					key_actions_load_layer(config, config.active_layer[i].data[0]);
+					return_data.data_present = 1;
+				}
+				break;
+
+			case layer_node_mouse_buttons:
+				if (config.key_list[i]->key_status == key_pressed) {
+					u8 but_no = config.active_layer[i].data[0];
+					if (but_no >= 0 && but_no <= 5)
+						return_data.mouse_buttons |= BIT(but_no);
+					return_data.data_present = 1;
+				}
+				break;
+		}
+	}
+
+	return return_data;
+}
+
+void key_actions_load_layer(struct key_actions_config_t config, u8 layer_no)
+{
+	if (layer_no >= config.layer_list_size)
+		return;
+
+	for (size_t i = 0; i < config.key_list_size; i++) config.active_layer[i] = config.layer_list[layer_no][i];
+}

src/key_actions/key_actions.h

@@ -0,0 +1,49 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: 2021 Rafael Silva <perigoso@riseup.net>
+ */
+
+#pragma once
+
+#include "util/types.h"
+
+enum key_status_t {
+	key_released = 0b0,
+	key_pressed = 0b1,
+};
+
+struct key_t {
+	u16 key_status : 1;
+	u16 key_t_delta : 15; /* time delta since change, used to determine tap and hold behaviour*/
+};
+
+enum layer_node_actions_t {
+	layer_node_none, /* no action */
+	layer_node_regular, /* regular keystroke, send keycode on data[0] */
+	layer_node_tap_hold, /* send keycode on data[0] on tap, keycode on data[1] on hold */
+	layer_node_set_layer, /* set layer specified on data[0] */
+	layer_node_mouse_buttons, /* send mouse button, index on data[0] (1-5) */
+};
+
+struct layer_node_t {
+	u8 node_action;
+	u8 data[3]; /* data use depends on action */
+};
+
+struct key_actions_config_t {
+	struct key_t **key_list; /* array of pointers to key_t structs, these are provided by low level platform drivers */
+	u8 key_list_size; /* number of key_t elements */
+	struct layer_node_t **layer_list; /* array of layers (arrays of layer_node_t, size must be the same as key_list_size) */
+	u8 layer_list_size; /* number of available layers on layer_list */
+	struct layer_node_t *active_layer; /* used internally, array of layer_node_t, size must be the same as key_list_size */
+	u16 tap_interval; /* setting for tap/hold behaviour, keystrokes longer than tap_interval (ms) are holds */
+};
+
+struct key_actions_return_t {
+	u8 data_present; /* if there is data returned */
+	u8 keycodes[6]; /* keycode array for hid keyboard report */
+	u8 mouse_buttons; /* mouse button state */
+};
+
+struct key_actions_return_t key_actions_update(struct key_actions_config_t config);
+void key_actions_load_layer(struct key_actions_config_t config, u8 layer_no);

src/platform/efm32gg/driver/key_direct.c

@@ -0,0 +1,31 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: 2021 Rafael Silva <perigoso@riseup.net>
+ */
+
+#include "platform/efm32gg/driver/key_direct.h"
+#include "platform/efm32gg/systick.h"
+
+struct key_direct_t key_direct_init(struct gpio_pin_t pin, u8 active_low)
+{
+	struct key_direct_t key;
+
+	key.pin = pin;
+	key.active_low = active_low;
+	key.key.key_status = key_released;
+	key.change_timestamp = systick_get_ticks();
+
+	return key;
+}
+
+void key_direct_update(struct key_direct_t *key)
+{
+	enum key_status_t last_status = key->key.key_status;
+
+	key->key.key_status = (gpio_get(key->pin) ^ key->active_low) ? key_pressed : key_released;
+
+	if (key->key.key_status != last_status)
+		key->change_timestamp = systick_get_ticks();
+
+	key->key.key_t_delta = systick_get_ticks() - key->change_timestamp;
+}

src/platform/efm32gg/driver/key_direct.h

@@ -0,0 +1,22 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: 2021 Rafael Silva <perigoso@riseup.net>
+ */
+
+#pragma once
+
+#include "util/types.h"
+
+#include "platform/efm32gg/gpio.h"
+
+#include "key_actions/key_actions.h"
+
+struct key_direct_t {
+	struct gpio_pin_t pin;
+	u32 change_timestamp;
+	u8 active_low : 1;
+	struct key_t key;
+};
+
+struct key_direct_t key_direct_init(struct gpio_pin_t pin, u8 active_low);
+void key_direct_update(struct key_direct_t *key);

src/platform/efm32gg/driver/key_matrix.c

@@ -0,0 +1,61 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: 2021 Rafael Silva <perigoso@riseup.net>
+ */
+
+#include "platform/efm32gg/driver/key_matrix.h"
+#include "platform/efm32gg/systick.h"
+
+struct key_matrix_t key_matrix_init(
+	struct gpio_pin_t *col_pin_list,
+	u8 col_pin_list_size,
+	struct gpio_pin_t *row_pin_list,
+	u8 row_pin_list_size,
+	struct key_t *key_data,
+	u8 col_to_row)
+{
+	struct key_matrix_t matrix = {};
+
+	matrix.col_pin_list = col_pin_list;
+	matrix.col_pin_list_size = col_pin_list_size;
+	matrix.row_pin_list = row_pin_list;
+	matrix.row_pin_list_size = row_pin_list_size;
+	matrix.key_data = key_data;
+	matrix.col_to_row = col_to_row;
+	matrix.update_timestamp = systick_get_ticks();
+
+	for (size_t col = 0; col < matrix.col_pin_list_size; col++) gpio_set(col_pin_list[col], !matrix.col_to_row);
+
+	return matrix;
+}
+
+void key_matrix_scan(struct key_matrix_t *matrix)
+{
+	u16 t_delta = systick_get_ticks() - matrix->update_timestamp;
+	matrix->update_timestamp = systick_get_ticks();
+
+	for (size_t col = 0; col < matrix->col_pin_list_size; col++) {
+		/* set col output */
+		gpio_set(matrix->col_pin_list[col], matrix->col_to_row);
+
+		for (size_t row = 0; row < matrix->row_pin_list_size; row++) {
+			u8 index = (col * matrix->row_pin_list_size) + row;
+			enum key_status_t last_status = matrix->key_data[index].key_status;
+
+			/* get row input */
+			matrix->key_data[index].key_status =
+				(gpio_get(matrix->row_pin_list[row]) ^ matrix->col_to_row) ? key_released : key_pressed;
+
+			if (matrix->key_data[index].key_status != last_status)
+				matrix->key_data[index].key_t_delta = 0;
+			else
+				matrix->key_data[index].key_t_delta += t_delta;
+		}
+
+		/* clear col output */
+		gpio_set(matrix->col_pin_list[col], !matrix->col_to_row);
+
+		/* settle time */
+		delay_us(1);
+	}
+}

src/platform/efm32gg/driver/key_matrix.h

@@ -0,0 +1,31 @@
+/*
+ * SPDX-License-Identifier: MIT
+ * SPDX-FileCopyrightText: 2021 Rafael Silva <perigoso@riseup.net>
+ */
+
+#pragma once
+
+#include "util/types.h"
+
+#include "platform/efm32gg/gpio.h"
+
+#include "key_actions/key_actions.h"
+
+struct key_matrix_t {
+	struct gpio_pin_t *col_pin_list;
+	u8 col_pin_list_size;
+	struct gpio_pin_t *row_pin_list;
+	u8 row_pin_list_size;
+	struct key_t *key_data;
+	u32 update_timestamp;
+	u8 col_to_row : 1;
+};
+
+struct key_matrix_t key_matrix_init(
+	struct gpio_pin_t *col_pin_list,
+	u8 col_pin_list_size,
+	struct gpio_pin_t *row_pin_list,
+	u8 row_pin_list_size,
+	struct key_t *key_data,
+	u8 col_to_row);
+void key_matrix_scan(struct key_matrix_t *matrix);

src/util/hid_descriptors.h

@@ -59,7 +59,6 @@ struct keyboard_report {
 	u8 modifiers;
 	u8 reserved;
 	u8 keys[6];
-	u8 leds : 5;
 } __attribute__((__packed__));
 
 /* HID keyboard report descriptor */