294 lines
6.9 KiB
C
294 lines
6.9 KiB
C
/*
|
|
* Copyright 2023 Google LLC
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <zephyr/input/input.h>
|
|
#ifdef CONFIG_INPUT_SHELL_KBD_MATRIX_STATE
|
|
#include <zephyr/input/input_kbd_matrix.h>
|
|
#endif
|
|
#include <zephyr/logging/log.h>
|
|
#include <zephyr/shell/shell.h>
|
|
#include <zephyr/sys/atomic.h>
|
|
|
|
LOG_MODULE_DECLARE(input);
|
|
|
|
#ifdef CONFIG_INPUT_EVENT_DUMP
|
|
#ifdef CONFIG_INPUT_SHELL
|
|
static atomic_t dump_enable;
|
|
|
|
static bool input_dump_enabled(void)
|
|
{
|
|
return atomic_get(&dump_enable);
|
|
}
|
|
|
|
static int input_cmd_dump(const struct shell *sh, size_t argc, char *argv[])
|
|
{
|
|
bool enabled;
|
|
int err = 0;
|
|
|
|
enabled = shell_strtobool(argv[1], 0, &err);
|
|
if (err) {
|
|
shell_error(sh, "Invalid argument: %s", argv[1]);
|
|
return err;
|
|
}
|
|
|
|
if (enabled) {
|
|
shell_info(sh, "Input event dumping enabled");
|
|
atomic_set(&dump_enable, 1);
|
|
} else {
|
|
atomic_set(&dump_enable, 0);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#else
|
|
static bool input_dump_enabled(void)
|
|
{
|
|
return true;
|
|
}
|
|
#endif /* CONFIG_INPUT_SHELL */
|
|
|
|
static void input_dump_cb(struct input_event *evt, void *user_data)
|
|
{
|
|
ARG_UNUSED(user_data);
|
|
|
|
if (!input_dump_enabled()) {
|
|
return;
|
|
}
|
|
|
|
LOG_INF("input event: dev=%-16s %3s type=%2x code=%3d value=%d",
|
|
evt->dev ? evt->dev->name : "NULL",
|
|
evt->sync ? "SYN" : "",
|
|
evt->type,
|
|
evt->code,
|
|
evt->value);
|
|
}
|
|
INPUT_CALLBACK_DEFINE(NULL, input_dump_cb, NULL);
|
|
#endif /* CONFIG_INPUT_EVENT_DUMP */
|
|
|
|
#ifdef CONFIG_INPUT_SHELL
|
|
static int input_cmd_report(const struct shell *sh, size_t argc, char *argv[])
|
|
{
|
|
bool sync;
|
|
int err = 0;
|
|
uint32_t type, code, value;
|
|
|
|
if (argc == 5) {
|
|
sync = shell_strtobool(argv[4], 0, &err);
|
|
if (err) {
|
|
shell_error(sh, "Invalid argument: %s", argv[4]);
|
|
return err;
|
|
}
|
|
} else {
|
|
sync = true;
|
|
}
|
|
|
|
type = shell_strtoul(argv[1], 0, &err);
|
|
if (err) {
|
|
shell_error(sh, "Invalid argument: %s", argv[1]);
|
|
return err;
|
|
}
|
|
if (type > UINT8_MAX) {
|
|
shell_error(sh, "Out of range: %s", argv[1]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
code = shell_strtoul(argv[2], 0, &err);
|
|
if (err) {
|
|
shell_error(sh, "Invalid argument: %s", argv[2]);
|
|
return err;
|
|
}
|
|
if (code > UINT16_MAX) {
|
|
shell_error(sh, "Out of range: %s", argv[2]);
|
|
return -EINVAL;
|
|
}
|
|
|
|
value = shell_strtoul(argv[3], 0, &err);
|
|
if (err) {
|
|
shell_error(sh, "Invalid argument: %s", argv[3]);
|
|
return err;
|
|
}
|
|
|
|
input_report(NULL, type, code, value, sync, K_FOREVER);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_INPUT_SHELL_KBD_MATRIX_STATE
|
|
static const struct device *kbd_matrix_state_dev;
|
|
static kbd_row_t kbd_matrix_state[CONFIG_INPUT_SHELL_KBD_MATRIX_STATE_MAX_COLS];
|
|
static kbd_row_t kbd_matrix_key_mask[CONFIG_INPUT_SHELL_KBD_MATRIX_STATE_MAX_COLS];
|
|
|
|
/* Keep space for each column value, 2 char per byte + space. */
|
|
#define KEY_MATRIX_ENTRY_LEN (sizeof(kbd_row_t) * 2 + 1)
|
|
#define KEY_MATRIX_BUF_SZ (CONFIG_INPUT_SHELL_KBD_MATRIX_STATE_MAX_COLS * \
|
|
KEY_MATRIX_ENTRY_LEN)
|
|
static char kbd_matrix_buf[KEY_MATRIX_BUF_SZ];
|
|
|
|
static void kbd_matrix_state_log_entry(char *header, kbd_row_t *data)
|
|
{
|
|
const struct input_kbd_matrix_common_config *cfg = kbd_matrix_state_dev->config;
|
|
char *buf = kbd_matrix_buf;
|
|
int size = sizeof(kbd_matrix_buf);
|
|
int ret;
|
|
char blank[KEY_MATRIX_ENTRY_LEN];
|
|
int count = 0;
|
|
|
|
memset(blank, '-', sizeof(blank) - 1);
|
|
blank[sizeof(blank) - 1] = '\0';
|
|
|
|
for (int i = 0; i < cfg->col_size; i++) {
|
|
char *sep = (i + 1) < cfg->col_size ? " " : "";
|
|
|
|
if (data[i] != 0) {
|
|
ret = snprintf(buf, size, "%" PRIkbdrow "%s", data[i], sep);
|
|
} else {
|
|
ret = snprintf(buf, size, "%s%s", blank, sep);
|
|
}
|
|
size -= ret;
|
|
buf += ret;
|
|
|
|
count += POPCOUNT(data[i]);
|
|
|
|
/* Last byte is for the string termination */
|
|
if (size < 1) {
|
|
LOG_ERR("kbd_matrix_buf too small");
|
|
return;
|
|
}
|
|
}
|
|
|
|
LOG_INF("%s %s [%s] (%d)",
|
|
kbd_matrix_state_dev->name, header, kbd_matrix_buf, count);
|
|
}
|
|
|
|
static void kbd_matrix_state_log(struct input_event *evt, void *user_data)
|
|
{
|
|
const struct input_kbd_matrix_common_config *cfg;
|
|
static uint32_t row, col;
|
|
static bool val;
|
|
|
|
ARG_UNUSED(user_data);
|
|
|
|
if (kbd_matrix_state_dev == NULL || kbd_matrix_state_dev != evt->dev) {
|
|
return;
|
|
}
|
|
|
|
cfg = kbd_matrix_state_dev->config;
|
|
|
|
switch (evt->code) {
|
|
case INPUT_ABS_X:
|
|
col = evt->value;
|
|
break;
|
|
case INPUT_ABS_Y:
|
|
row = evt->value;
|
|
break;
|
|
case INPUT_BTN_TOUCH:
|
|
val = evt->value;
|
|
break;
|
|
}
|
|
|
|
if (!evt->sync) {
|
|
return;
|
|
}
|
|
|
|
if (col > (CONFIG_INPUT_SHELL_KBD_MATRIX_STATE_MAX_COLS - 1)) {
|
|
LOG_ERR("column index too large for the state buffer: %d", col);
|
|
return;
|
|
}
|
|
|
|
if (col > (cfg->col_size - 1)) {
|
|
LOG_ERR("invalid column index: %d", col);
|
|
return;
|
|
}
|
|
|
|
if (row > (cfg->row_size - 1)) {
|
|
LOG_ERR("invalid row index: %d", row);
|
|
return;
|
|
}
|
|
|
|
WRITE_BIT(kbd_matrix_state[col], row, val);
|
|
if (val != 0) {
|
|
WRITE_BIT(kbd_matrix_key_mask[col], row, 1);
|
|
}
|
|
|
|
kbd_matrix_state_log_entry("state", kbd_matrix_state);
|
|
}
|
|
INPUT_CALLBACK_DEFINE(NULL, kbd_matrix_state_log, NULL);
|
|
|
|
static int input_cmd_kbd_matrix_state_dump(const struct shell *sh,
|
|
size_t argc, char *argv[])
|
|
{
|
|
const struct device *dev;
|
|
|
|
if (!strcmp(argv[1], "off")) {
|
|
if (kbd_matrix_state_dev != NULL) {
|
|
kbd_matrix_state_log_entry("key-mask",
|
|
kbd_matrix_key_mask);
|
|
}
|
|
|
|
kbd_matrix_state_dev = NULL;
|
|
shell_info(sh, "Keyboard state logging disabled");
|
|
return 0;
|
|
}
|
|
|
|
dev = device_get_binding(argv[1]);
|
|
if (dev == NULL) {
|
|
shell_error(sh, "Invalid device: %s", argv[1]);
|
|
return -ENODEV;
|
|
}
|
|
|
|
if (kbd_matrix_state_dev != NULL && kbd_matrix_state_dev != dev) {
|
|
shell_error(sh, "Already logging for %s, disable logging first",
|
|
kbd_matrix_state_dev->name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
memset(kbd_matrix_state, 0, sizeof(kbd_matrix_state));
|
|
memset(kbd_matrix_key_mask, 0, sizeof(kbd_matrix_state));
|
|
kbd_matrix_state_dev = dev;
|
|
|
|
shell_info(sh, "Keyboard state logging enabled for %s", dev->name);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void device_name_get(size_t idx, struct shell_static_entry *entry)
|
|
{
|
|
const struct device *dev = shell_device_lookup(idx, NULL);
|
|
|
|
entry->syntax = (dev != NULL) ? dev->name : NULL;
|
|
entry->handler = NULL;
|
|
entry->help = NULL;
|
|
entry->subcmd = NULL;
|
|
}
|
|
|
|
SHELL_DYNAMIC_CMD_CREATE(dsub_device_name, device_name_get);
|
|
#endif /* CONFIG_INPUT_SHELL_KBD_MATRIX_STATE */
|
|
|
|
SHELL_STATIC_SUBCMD_SET_CREATE(
|
|
sub_input_cmds,
|
|
#ifdef CONFIG_INPUT_EVENT_DUMP
|
|
SHELL_CMD_ARG(dump, NULL,
|
|
"Enable event dumping\n"
|
|
"usage: dump <on|off>",
|
|
input_cmd_dump, 2, 0),
|
|
#endif /* CONFIG_INPUT_EVENT_DUMP */
|
|
#ifdef CONFIG_INPUT_SHELL_KBD_MATRIX_STATE
|
|
SHELL_CMD_ARG(kbd_matrix_state_dump, &dsub_device_name,
|
|
"Print the state of a keyboard matrix device each time a "
|
|
"key is pressed or released\n"
|
|
"usage: kbd_matrix_state_dump <device>|off",
|
|
input_cmd_kbd_matrix_state_dump, 2, 0),
|
|
#endif /* CONFIG_INPUT_SHELL_KBD_MATRIX_STATE */
|
|
SHELL_CMD_ARG(report, NULL,
|
|
"Trigger an input report event\n"
|
|
"usage: report <type> <code> <value> [<sync>]",
|
|
input_cmd_report, 4, 1),
|
|
SHELL_SUBCMD_SET_END);
|
|
|
|
SHELL_CMD_REGISTER(input, &sub_input_cmds, "Input commands", NULL);
|
|
#endif /* CONFIG_INPUT_SHELL */
|