blob: 56d9b248e201e9476ca6639337cfa522e3d59801 [file] [log] [blame] [edit]
/*
* Copyright (c) 2020 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/shell/shell.h>
#include <stdlib.h>
#include <zephyr/drivers/virtualization/ivshmem.h>
static const struct device *ivshmem;
#ifdef CONFIG_IVSHMEM_DOORBELL
#define STACK_SIZE 512
static struct k_poll_signal doorbell_sig =
K_POLL_SIGNAL_INITIALIZER(doorbell_sig);
static struct k_poll_event doorbell_evt =
K_POLL_EVENT_INITIALIZER(K_POLL_TYPE_SIGNAL,
K_POLL_MODE_NOTIFY_ONLY,
&doorbell_sig);
K_THREAD_STACK_DEFINE(doorbell_stack, STACK_SIZE);
static bool doorbell_started;
static struct k_thread doorbell_thread;
static void doorbell_notification_thread(const struct shell *sh)
{
while (1) {
unsigned int signaled;
int vector;
k_poll(&doorbell_evt, 1, K_FOREVER);
k_poll_signal_check(&doorbell_sig, &signaled, &vector);
if (signaled == 0) {
continue;
}
shell_fprintf(sh, SHELL_NORMAL,
"Received a notification on vector %u\n",
(unsigned int)vector);
k_poll_signal_init(&doorbell_sig);
}
}
#endif /* CONFIG_IVSHMEM_DOORBELL */
static bool get_ivshmem(const struct shell *sh)
{
if (ivshmem == NULL) {
ivshmem = DEVICE_DT_GET_ONE(qemu_ivshmem);
if (!device_is_ready(ivshmem)) {
shell_error(sh, "IVshmem device is not ready");
}
}
return ivshmem != NULL ? true : false;
}
static int cmd_ivshmem_shmem(const struct shell *sh,
size_t argc, char **argv)
{
uintptr_t mem;
size_t size;
uint32_t id;
uint16_t vectors;
if (!get_ivshmem(sh)) {
return 0;
}
size = ivshmem_get_mem(ivshmem, &mem);
id = ivshmem_get_id(ivshmem);
vectors = ivshmem_get_vectors(ivshmem);
shell_fprintf(sh, SHELL_NORMAL,
"IVshmem up and running: \n"
"\tShared memory: 0x%x of size %u bytes\n"
"\tPeer id: %u\n"
"\tNotification vectors: %u\n",
mem, size, id, vectors);
return 0;
}
static int cmd_ivshmem_dump(const struct shell *sh,
size_t argc, char **argv)
{
uintptr_t dump_pos;
size_t dump_size;
uintptr_t mem;
size_t size;
if (!get_ivshmem(sh)) {
return 0;
}
dump_pos = strtol(argv[1], NULL, 10);
dump_size = strtol(argv[2], NULL, 10);
size = ivshmem_get_mem(ivshmem, &mem);
if (dump_size > size) {
shell_error(sh, "Size is too big");
} else if (dump_pos > size) {
shell_error(sh, "Position is out of the shared memory");
} else if ((mem + dump_pos + dump_size) > (mem + size)) {
shell_error(sh, "Position and size overflow");
} else {
shell_hexdump(sh, (const uint8_t *)mem+dump_pos, dump_size);
}
return 0;
}
static int cmd_ivshmem_int(const struct shell *sh,
size_t argc, char **argv)
{
int peer_id;
int vector;
int ret;
if (!IS_ENABLED(CONFIG_IVSHMEM_DOORBELL)) {
shell_error(sh, "CONFIG_IVSHMEM_DOORBELL is not enabled");
return 0;
}
if (!get_ivshmem(sh)) {
return 0;
}
peer_id = strtol(argv[1], NULL, 10);
vector = strtol(argv[2], NULL, 10);
ret = ivshmem_int_peer(ivshmem, (uint16_t)peer_id, (uint16_t)vector);
if (ret != 0) {
shell_error(sh,
"Could not notify peer %u on %u. status %d",
peer_id, vector, ret);
return -EIO;
}
shell_fprintf(sh, SHELL_NORMAL,
"Notification sent to peer %u on vector %u\n",
peer_id, vector);
return 0;
}
static int cmd_ivshmem_get_notified(const struct shell *sh,
size_t argc, char **argv)
{
#ifdef CONFIG_IVSHMEM_DOORBELL
int vector;
if (!get_ivshmem(sh)) {
return 0;
}
vector = strtol(argv[1], NULL, 10);
if (ivshmem_register_handler(ivshmem, &doorbell_sig,
(uint16_t)vector)) {
shell_error(sh, "Could not get notifications on vector %u",
vector);
return -EIO;
}
shell_fprintf(sh, SHELL_NORMAL,
"Notifications enabled for vector %u\n", vector);
if (!doorbell_started) {
k_tid_t tid;
tid = k_thread_create(
&doorbell_thread,
doorbell_stack, STACK_SIZE,
(k_thread_entry_t)doorbell_notification_thread,
(void *)sh, NULL, NULL,
K_PRIO_COOP(2), 0, K_NO_WAIT);
if (!tid) {
shell_error(sh, "Cannot start notification thread");
return -ENOEXEC;
}
k_thread_name_set(tid, "notification_thread");
k_thread_start(tid);
doorbell_started = true;
}
#else
shell_error(sh, "CONFIG_IVSHMEM_DOORBELL is not enabled");
#endif
return 0;
}
SHELL_STATIC_SUBCMD_SET_CREATE(sub_ivshmem_cmds,
SHELL_CMD(shmem, NULL,
"Show shared memory info",
cmd_ivshmem_shmem),
SHELL_CMD_ARG(dump, NULL,
"Dump shared memory content",
cmd_ivshmem_dump, 3, 0),
SHELL_CMD_ARG(int_peer, NULL,
"Notify a vector on a peer",
cmd_ivshmem_int, 3, 0),
SHELL_CMD_ARG(get_notified, NULL,
"Get notification on vector",
cmd_ivshmem_get_notified, 2, 0),
SHELL_SUBCMD_SET_END
);
SHELL_CMD_REGISTER(ivshmem, &sub_ivshmem_cmds,
"IVshmem information", cmd_ivshmem_shmem);
SHELL_CMD_ARG_REGISTER(ivshmem_dump, &sub_ivshmem_cmds,
"Dump shared memory content",
cmd_ivshmem_dump, 3, 0);
SHELL_CMD_ARG_REGISTER(ivshmem_int, &sub_ivshmem_cmds,
"Notify a vector on an ivshmem peer",
cmd_ivshmem_int, 3, 0);
SHELL_CMD_ARG_REGISTER(ivshmem_get_notified, &sub_ivshmem_cmds,
"Get notification on vector",
cmd_ivshmem_get_notified, 2, 0);