Converting Ethos-U driver to rpmsg
The Ethos-U kernel driver has been converted from a
platform driver with a custom firmware interface into a
rpmsg driver.
Change-Id: I9ae449f5e79eb02924e6630611d0893e5fec86be
diff --git a/kernel/ethosu_mailbox.c b/kernel/ethosu_mailbox.c
index 870a4ef..4c64f17 100644
--- a/kernel/ethosu_mailbox.c
+++ b/kernel/ethosu_mailbox.c
@@ -25,7 +25,7 @@
#include "ethosu_mailbox.h"
#include "ethosu_buffer.h"
-#include "ethosu_core_interface.h"
+#include "ethosu_core_rpmsg.h"
#include "ethosu_device.h"
#include <linux/jiffies.h>
@@ -62,192 +62,6 @@
cbuf->size = (uint32_t)buf->capacity - buf->offset - buf->size;
}
-static size_t ethosu_queue_available(struct ethosu_core_queue *queue)
-{
- size_t size = queue->header.write - queue->header.read;
-
- if (queue->header.read > queue->header.write)
- size += queue->header.size;
-
- return size;
-}
-
-static size_t ethosu_queue_capacity(struct ethosu_core_queue *queue)
-{
- return max_t(ssize_t,
- queue->header.size - ethosu_queue_available(queue) - 1, 0);
-}
-
-static int ethosu_queue_write(struct ethosu_mailbox *mbox,
- const struct kvec *vec,
- size_t length)
-{
- struct ethosu_core_queue *queue = mbox->in_queue;
- uint8_t *dst = &queue->data[0];
- uint32_t wpos = queue->header.write;
- size_t total_size;
- size_t i;
- int ret;
-
- for (i = 0, total_size = 0; i < length; i++)
- total_size += vec[i].iov_len;
-
- if (total_size > ethosu_queue_capacity(queue))
- return -EINVAL;
-
- for (i = 0; i < length; i++) {
- const uint8_t *src = vec[i].iov_base;
- const uint8_t *end = src + vec[i].iov_len;
-
- while (src < end) {
- dst[wpos] = *src++;
- wpos = (wpos + 1) % queue->header.size;
- }
- }
-
- queue->header.write = wpos;
-
- ret = mbox_send_message(mbox->tx, queue);
- if (ret < 0)
- return ret;
-
- return 0;
-}
-
-static int ethosu_queue_write_msg(struct ethosu_mailbox *mbox,
- uint32_t type,
- void *data,
- size_t length)
-{
- struct ethosu_core_msg msg = {
- .magic = ETHOSU_CORE_MSG_MAGIC,
- .type = type, .length= length
- };
- const struct kvec vec[2] = {
- { &msg, sizeof(msg) },
- { data, length }
- };
- int ret;
-
- ret = ethosu_queue_write(mbox, vec, 2);
- if (ret)
- return ret;
-
- return 0;
-}
-
-static int ethosu_queue_read(struct ethosu_mailbox *mbox,
- void *data,
- size_t length)
-{
- struct ethosu_core_queue *queue = mbox->out_queue;
- uint8_t *src = &queue->data[0];
- uint8_t *dst = (uint8_t *)data;
- const uint8_t *end = dst + length;
- uint32_t rpos = queue->header.read;
- size_t queue_avail = ethosu_queue_available(queue);
-
- if (length == 0)
- return 0;
- else if (queue_avail == 0)
- return -ENOMSG;
- else if (length > queue_avail)
- return -EBADMSG;
-
- while (dst < end) {
- *dst++ = src[rpos];
- rpos = (rpos + 1) % queue->header.size;
- }
-
- queue->header.read = rpos;
-
- return 0;
-}
-
-void ethosu_mailbox_reset(struct ethosu_mailbox *mbox)
-{
- mbox->out_queue->header.read = mbox->out_queue->header.write;
-}
-
-void ethosu_mailbox_wait_prepare(struct ethosu_mailbox *mbox)
-{
- mbox->in_queue->header.size = 0;
- mbox->in_queue->header.read = 0xffffff;
- mbox->in_queue->header.write = 0xffffff;
-}
-
-int ethosu_mailbox_wait_firmware(struct ethosu_mailbox *mbox)
-{
- const unsigned long timeout = 1000;
- const unsigned long end = jiffies + msecs_to_jiffies(timeout);
- volatile struct ethosu_core_queue_header *hdr =
- &mbox->in_queue->header;
- int ret = -ETIMEDOUT;
-
- /* Spin wait on mailbox initialization */
- while ((end - jiffies) < timeout)
- if (hdr->size != 0 &&
- hdr->read != 0xffffff &&
- hdr->write != 0xffffff) {
- ret = 0;
- break;
- }
-
- dev_info(mbox->dev, "mbox: Wait. ret=%d, size=%u, read=%u, write=%u",
- ret, hdr->size, hdr->read, hdr->write);
-
- return ret;
-}
-
-int ethosu_mailbox_read(struct ethosu_mailbox *mbox,
- struct ethosu_core_msg *header,
- void *data,
- size_t length)
-{
- int ret;
-
- /* Read message header magic */
- ret = ethosu_queue_read(mbox, header, sizeof(*header));
- if (ret) {
- if (ret != -ENOMSG)
- dev_warn(mbox->dev,
- "Msg: Failed to read message header\n");
-
- return ret;
- }
-
- if (header->magic != ETHOSU_CORE_MSG_MAGIC) {
- dev_warn(mbox->dev,
- "Msg: Invalid magic. Got: %08X but expected %08X\n",
- header->magic, ETHOSU_CORE_MSG_MAGIC);
-
- return -EINVAL;
- }
-
- dev_info(mbox->dev,
- "mbox: Read msg header. magic=%08X, type=%u, length=%u",
- header->magic, header->type, header->length);
-
- /* Check that payload is not larger than allocated buffer */
- if (header->length > length) {
- dev_warn(mbox->dev,
- "Msg: Buffer size (%zu) too small for message (%u)\n",
- sizeof(data), header->length);
-
- return -ENOMEM;
- }
-
- /* Read payload data */
- ret = ethosu_queue_read(mbox, data, header->length);
- if (ret) {
- dev_warn(mbox->dev, "Msg: Failed to read payload data\n");
-
- return -EBADMSG;
- }
-
- return 0;
-}
-
int ethosu_mailbox_register(struct ethosu_mailbox *mbox,
struct ethosu_mailbox_msg *msg)
{
@@ -288,30 +102,52 @@
int ethosu_mailbox_ping(struct ethosu_mailbox *mbox)
{
- return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_PING, NULL, 0);
+ struct ethosu_core_rpmsg rpmsg = {
+ .header = {
+ .magic = ETHOSU_CORE_MSG_MAGIC,
+ .type = ETHOSU_CORE_MSG_PING,
+ }
+ };
+
+ return rpmsg_send(mbox->ept, &rpmsg, sizeof(rpmsg.header));
}
int ethosu_mailbox_pong(struct ethosu_mailbox *mbox)
{
- return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_PONG, NULL, 0);
+ struct ethosu_core_rpmsg rpmsg = {
+ .header = {
+ .magic = ETHOSU_CORE_MSG_MAGIC,
+ .type = ETHOSU_CORE_MSG_PONG,
+ }
+ };
+
+ return rpmsg_send(mbox->ept, &rpmsg, sizeof(rpmsg.header));
}
int ethosu_mailbox_version_request(struct ethosu_mailbox *mbox)
{
- return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_VERSION_REQ, NULL,
- 0);
+ struct ethosu_core_rpmsg rpmsg = {
+ .header = {
+ .magic = ETHOSU_CORE_MSG_MAGIC,
+ .type = ETHOSU_CORE_MSG_VERSION_REQ,
+ }
+ };
+
+ return rpmsg_send(mbox->ept, &rpmsg, sizeof(rpmsg.header));
}
int ethosu_mailbox_capabilities_request(struct ethosu_mailbox *mbox,
struct ethosu_mailbox_msg *msg)
{
- struct ethosu_core_capabilities_req req = {
- .user_arg = msg->id
+ struct ethosu_core_rpmsg rpmsg = {
+ .header = {
+ .magic = ETHOSU_CORE_MSG_MAGIC,
+ .type = ETHOSU_CORE_MSG_CAPABILITIES_REQ,
+ .msg_id = msg->id
+ }
};
- return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_CAPABILITIES_REQ,
- &req,
- sizeof(req));
+ return rpmsg_send(mbox->ept, &rpmsg, sizeof(rpmsg.header));
}
int ethosu_mailbox_inference(struct ethosu_mailbox *mbox,
@@ -326,40 +162,46 @@
uint8_t pmu_event_config_count,
uint8_t pmu_cycle_counter_enable)
{
- struct ethosu_core_inference_req inf;
+ struct ethosu_core_rpmsg rpmsg = {
+ .header = {
+ .magic = ETHOSU_CORE_MSG_MAGIC,
+ .type = ETHOSU_CORE_MSG_INFERENCE_REQ,
+ .msg_id = msg->id
+ }
+ };
+ struct ethosu_core_msg_inference_req *inf_req = &rpmsg.inf_req;
uint32_t i;
/* Verify that the uapi and core has the same number of pmus */
if (pmu_event_config_count != ETHOSU_CORE_PMU_MAX) {
- dev_err(mbox->dev, "PMU count misconfigured.\n");
+ dev_err(mbox->dev, "PMU count misconfigured.");
return -EINVAL;
}
- inf.user_arg = msg->id;
- inf.ifm_count = ifm_count;
- inf.ofm_count = ofm_count;
- inf.pmu_cycle_counter_enable = pmu_cycle_counter_enable;
+ inf_req->ifm_count = ifm_count;
+ inf_req->ofm_count = ofm_count;
+ inf_req->pmu_cycle_counter_enable = pmu_cycle_counter_enable;
for (i = 0; i < ifm_count; i++)
- ethosu_core_set_size(ifm[i], &inf.ifm[i]);
+ ethosu_core_set_size(ifm[i], &inf_req->ifm[i]);
for (i = 0; i < ofm_count; i++)
- ethosu_core_set_capacity(ofm[i], &inf.ofm[i]);
+ ethosu_core_set_capacity(ofm[i], &inf_req->ofm[i]);
for (i = 0; i < ETHOSU_CORE_PMU_MAX; i++)
- inf.pmu_event_config[i] = pmu_event_config[i];
+ inf_req->pmu_event_config[i] = pmu_event_config[i];
if (network != NULL) {
- inf.network.type = ETHOSU_CORE_NETWORK_BUFFER;
- ethosu_core_set_size(network, &inf.network.buffer);
+ inf_req->network.type = ETHOSU_CORE_NETWORK_BUFFER;
+ ethosu_core_set_size(network, &inf_req->network.buffer);
} else {
- inf.network.type = ETHOSU_CORE_NETWORK_INDEX;
- inf.network.index = network_index;
+ inf_req->network.type = ETHOSU_CORE_NETWORK_INDEX;
+ inf_req->network.index = network_index;
}
- return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_INFERENCE_REQ,
- &inf, sizeof(inf));
+ return rpmsg_send(mbox->ept, &rpmsg,
+ sizeof(rpmsg.header) + sizeof(rpmsg.inf_req));
}
int ethosu_mailbox_network_info_request(struct ethosu_mailbox *mbox,
@@ -367,141 +209,57 @@
struct ethosu_buffer *network,
uint32_t network_index)
{
- struct ethosu_core_network_info_req info;
-
- info.user_arg = msg->id;
+ struct ethosu_core_rpmsg rpmsg = {
+ .header = {
+ .magic = ETHOSU_CORE_MSG_MAGIC,
+ .type = ETHOSU_CORE_MSG_NETWORK_INFO_REQ,
+ .msg_id = msg->id
+ }
+ };
+ struct ethosu_core_msg_network_info_req *info_req = &rpmsg.net_info_req;
if (network != NULL) {
- info.network.type = ETHOSU_CORE_NETWORK_BUFFER;
- ethosu_core_set_size(network, &info.network.buffer);
+ info_req->network.type = ETHOSU_CORE_NETWORK_BUFFER;
+ ethosu_core_set_size(network, &info_req->network.buffer);
} else {
- info.network.type = ETHOSU_CORE_NETWORK_INDEX;
- info.network.index = network_index;
+ info_req->network.type = ETHOSU_CORE_NETWORK_INDEX;
+ info_req->network.index = network_index;
}
- return ethosu_queue_write_msg(mbox, ETHOSU_CORE_MSG_NETWORK_INFO_REQ,
- &info, sizeof(info));
+ return rpmsg_send(mbox->ept, &rpmsg,
+ sizeof(rpmsg.header) + sizeof(rpmsg.net_info_req));
}
int ethosu_mailbox_cancel_inference(struct ethosu_mailbox *mbox,
struct ethosu_mailbox_msg *msg,
int inference_handle)
{
- struct ethosu_core_cancel_inference_req req;
+ struct ethosu_core_rpmsg rpmsg = {
+ .header = {
+ .magic = ETHOSU_CORE_MSG_MAGIC,
+ .type =
+ ETHOSU_CORE_MSG_CANCEL_INFERENCE_REQ,
+ .msg_id = msg->id
+ },
+ .cancel_req = {
+ .inference_handle = inference_handle
+ }
+ };
- req.user_arg = msg->id;
- req.inference_handle = inference_handle;
-
- return ethosu_queue_write_msg(mbox,
- ETHOSU_CORE_MSG_CANCEL_INFERENCE_REQ,
- &req, sizeof(req));
-}
-
-static void ethosu_mailbox_rx_work(struct work_struct *work)
-{
- struct ethosu_mailbox *mbox = container_of(work, typeof(*mbox), work);
-
- mbox->callback(mbox->user_arg);
-}
-
-static void ethosu_mailbox_rx_callback(struct mbox_client *client,
- void *message)
-{
- struct ethosu_mailbox *mbox =
- container_of(client, typeof(*mbox), client);
-
- dev_info(mbox->dev, "mbox: Received message.\n");
-
- queue_work(mbox->wq, &mbox->work);
-}
-
-static void ethosu_mailbox_tx_done(struct mbox_client *client,
- void *message,
- int r)
-{
- if (r)
- dev_warn(client->dev, "mbox: Failed sending message (%d)\n", r);
- else
- dev_info(client->dev, "mbox: Message sent\n");
+ return rpmsg_send(mbox->ept, &rpmsg,
+ sizeof(rpmsg.header) + sizeof(rpmsg.cancel_req));
}
int ethosu_mailbox_init(struct ethosu_mailbox *mbox,
struct device *dev,
- struct resource *in_queue,
- struct resource *out_queue,
- ethosu_mailbox_cb callback,
- void *user_arg)
+ struct rpmsg_endpoint *ept)
{
- int ret;
-
mbox->dev = dev;
- mbox->callback = callback;
- mbox->user_arg = user_arg;
+ mbox->ept = ept;
idr_init(&mbox->msg_idr);
- mbox->client.dev = dev;
- mbox->client.rx_callback = ethosu_mailbox_rx_callback;
- mbox->client.tx_prepare = NULL; /* preparation of data is handled
- * through the
- * queue functions */
- mbox->client.tx_done = ethosu_mailbox_tx_done;
- mbox->client.tx_block = true;
- mbox->client.knows_txdone = false;
- mbox->client.tx_tout = 500;
-
- mbox->in_queue = devm_ioremap_resource(mbox->dev, in_queue);
- if (IS_ERR(mbox->in_queue))
- return PTR_ERR(mbox->in_queue);
-
- mbox->out_queue = devm_ioremap_resource(mbox->dev, out_queue);
- if (IS_ERR(mbox->out_queue)) {
- ret = PTR_ERR(mbox->out_queue);
- goto unmap_in_queue;
- }
-
- mbox->wq = create_singlethread_workqueue("ethosu_workqueue");
- if (!mbox->wq) {
- dev_err(mbox->dev, "Failed to create work queue\n");
- ret = -EINVAL;
- goto unmap_out_queue;
- }
-
- INIT_WORK(&mbox->work, ethosu_mailbox_rx_work);
-
- mbox->tx = mbox_request_channel_byname(&mbox->client, "tx");
- if (IS_ERR(mbox->tx)) {
- dev_warn(mbox->dev, "mbox: Failed to request tx channel\n");
- ret = PTR_ERR(mbox->tx);
- goto workqueue_destroy;
- }
-
- mbox->rx = mbox_request_channel_byname(&mbox->client, "rx");
- if (IS_ERR(mbox->rx)) {
- dev_info(dev, "mbox: Using same channel for RX and TX\n");
- mbox->rx = mbox->tx;
- }
-
return 0;
-
-workqueue_destroy:
- destroy_workqueue(mbox->wq);
-
-unmap_out_queue:
- devm_iounmap(mbox->dev, mbox->out_queue);
-
-unmap_in_queue:
- devm_iounmap(mbox->dev, mbox->in_queue);
-
- return ret;
}
void ethosu_mailbox_deinit(struct ethosu_mailbox *mbox)
-{
- if (mbox->rx != mbox->tx)
- mbox_free_channel(mbox->rx);
-
- mbox_free_channel(mbox->tx);
- destroy_workqueue(mbox->wq);
- devm_iounmap(mbox->dev, mbox->out_queue);
- devm_iounmap(mbox->dev, mbox->in_queue);
-}
+{}