forked from torvalds/linux
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
mailbox: Add Gunyah message queue mailbox
Gunyah message queues are a unidirectional inter-VM pipe for messages up to 1024 bytes. This driver supports pairing a receiver message queue and a transmitter message queue to expose a single mailbox channel. Signed-off-by: Elliot Berman <quic_eberman@quicinc.com>
- Loading branch information
1 parent
c0e143d
commit b427188
Showing
4 changed files
with
280 additions
and
0 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,214 @@ | ||
// SPDX-License-Identifier: GPL-2.0-only | ||
/* | ||
* Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved. | ||
*/ | ||
|
||
#include <linux/mailbox_controller.h> | ||
#include <linux/module.h> | ||
#include <linux/interrupt.h> | ||
#include <linux/gunyah.h> | ||
#include <linux/printk.h> | ||
#include <linux/init.h> | ||
#include <linux/slab.h> | ||
#include <linux/wait.h> | ||
|
||
#define mbox_chan_to_msgq(chan) (container_of(chan->mbox, struct gh_msgq, mbox)) | ||
|
||
static irqreturn_t gh_msgq_rx_irq_handler(int irq, void *data) | ||
{ | ||
struct gh_msgq *msgq = data; | ||
struct gh_msgq_rx_data rx_data; | ||
enum gh_error err; | ||
bool ready = true; | ||
|
||
while (ready) { | ||
err = gh_hypercall_msgq_recv(msgq->rx_ghrsc->capid, | ||
(uintptr_t)&rx_data.data, sizeof(rx_data.data), | ||
&rx_data.length, &ready); | ||
if (err != GH_ERROR_OK) { | ||
if (err != GH_ERROR_MSGQUEUE_EMPTY) | ||
pr_warn("Failed to receive data from msgq for %s: %d\n", | ||
msgq->mbox.dev ? dev_name(msgq->mbox.dev) : "", err); | ||
break; | ||
} | ||
mbox_chan_received_data(gh_msgq_chan(msgq), &rx_data); | ||
} | ||
|
||
return IRQ_HANDLED; | ||
} | ||
|
||
/* Fired when message queue transitions from "full" to "space available" to send messages */ | ||
static irqreturn_t gh_msgq_tx_irq_handler(int irq, void *data) | ||
{ | ||
struct gh_msgq *msgq = data; | ||
|
||
mbox_chan_txdone(gh_msgq_chan(msgq), 0); | ||
|
||
return IRQ_HANDLED; | ||
} | ||
|
||
/* Fired after sending message and hypercall told us there was more space available. */ | ||
static void gh_msgq_txdone_tasklet(struct tasklet_struct *tasklet) | ||
{ | ||
struct gh_msgq *msgq = container_of(tasklet, struct gh_msgq, txdone_tasklet); | ||
|
||
mbox_chan_txdone(gh_msgq_chan(msgq), msgq->last_ret); | ||
} | ||
|
||
static int gh_msgq_send_data(struct mbox_chan *chan, void *data) | ||
{ | ||
struct gh_msgq *msgq = mbox_chan_to_msgq(chan); | ||
struct gh_msgq_tx_data *msgq_data = data; | ||
u64 tx_flags = 0; | ||
enum gh_error gh_error; | ||
bool ready; | ||
|
||
if (msgq_data->push) | ||
tx_flags |= GH_HYPERCALL_MSGQ_TX_FLAGS_PUSH; | ||
|
||
gh_error = gh_hypercall_msgq_send(msgq->tx_ghrsc->capid, msgq_data->length, | ||
(uintptr_t)msgq_data->data, tx_flags, &ready); | ||
|
||
/** | ||
* unlikely because Linux tracks state of msgq and should not try to | ||
* send message when msgq is full. | ||
*/ | ||
if (unlikely(gh_error == GH_ERROR_MSGQUEUE_FULL)) | ||
return -EAGAIN; | ||
|
||
/** | ||
* Propagate all other errors to client. If we return error to mailbox | ||
* framework, then no other messages can be sent and nobody will know | ||
* to retry this message. | ||
*/ | ||
msgq->last_ret = gh_remap_error(gh_error); | ||
|
||
/** | ||
* This message was successfully sent, but message queue isn't ready to | ||
* receive more messages because it's now full. Mailbox framework | ||
* requires that we only report that message was transmitted when | ||
* we're ready to transmit another message. We'll get that in the form | ||
* of tx IRQ once the other side starts to drain the msgq. | ||
*/ | ||
if (gh_error == GH_ERROR_OK && !ready) | ||
return 0; | ||
|
||
/** | ||
* We can send more messages. Mailbox framework requires that tx done | ||
* happens asynchronously to sending the message. Gunyah message queues | ||
* tell us right away on the hypercall return whether we can send more | ||
* messages. To work around this, defer the txdone to a tasklet. | ||
*/ | ||
tasklet_schedule(&msgq->txdone_tasklet); | ||
|
||
return 0; | ||
} | ||
|
||
static struct mbox_chan_ops gh_msgq_ops = { | ||
.send_data = gh_msgq_send_data, | ||
}; | ||
|
||
/** | ||
* gh_msgq_init() - Initialize a Gunyah message queue with an mbox_client | ||
* @parent: optional, device parent used for the mailbox controller | ||
* @msgq: Pointer to the gh_msgq to initialize | ||
* @cl: A mailbox client to bind to the mailbox channel that the message queue creates | ||
* @tx_ghrsc: optional, the transmission side of the message queue | ||
* @rx_ghrsc: optional, the receiving side of the message queue | ||
* | ||
* At least one of tx_ghrsc and rx_ghrsc should be not NULL. Most message queue use cases come with | ||
* a pair of message queues to facilitate bidirectional communication. When tx_ghrsc is set, | ||
* the client can send messages with mbox_send_message(gh_msgq_chan(msgq), msg). When rx_ghrsc | ||
* is set, the mbox_client should register an .rx_callback() and the message queue driver will | ||
* push all available messages upon receiving the RX ready interrupt. The messages should be | ||
* consumed or copied by the client right away as the gh_msgq_rx_data will be replaced/destroyed | ||
* after the callback. | ||
* | ||
* Returns - 0 on success, negative otherwise | ||
*/ | ||
int gh_msgq_init(struct device *parent, struct gh_msgq *msgq, struct mbox_client *cl, | ||
struct gunyah_resource *tx_ghrsc, struct gunyah_resource *rx_ghrsc) | ||
{ | ||
int ret; | ||
|
||
/* Must have at least a tx_ghrsc or rx_ghrsc and that they are the right device types */ | ||
if ((!tx_ghrsc && !rx_ghrsc) || | ||
(tx_ghrsc && tx_ghrsc->type != GUNYAH_RESOURCE_TYPE_MSGQ_TX) || | ||
(rx_ghrsc && rx_ghrsc->type != GUNYAH_RESOURCE_TYPE_MSGQ_RX)) | ||
return -EINVAL; | ||
|
||
if (gh_api_version() != GUNYAH_API_V1) { | ||
pr_err("Unrecognized gunyah version: %u. Currently supported: %d\n", | ||
gh_api_version(), GUNYAH_API_V1); | ||
return -EOPNOTSUPP; | ||
} | ||
|
||
if (!gh_api_has_feature(GH_API_FEATURE_MSGQUEUE)) | ||
return -EOPNOTSUPP; | ||
|
||
msgq->tx_ghrsc = tx_ghrsc; | ||
msgq->rx_ghrsc = rx_ghrsc; | ||
|
||
msgq->mbox.dev = parent; | ||
msgq->mbox.ops = &gh_msgq_ops; | ||
msgq->mbox.num_chans = 1; | ||
msgq->mbox.txdone_irq = true; | ||
msgq->mbox.chans = kcalloc(msgq->mbox.num_chans, sizeof(*msgq->mbox.chans), GFP_KERNEL); | ||
if (!msgq->mbox.chans) | ||
return -ENOMEM; | ||
|
||
if (msgq->tx_ghrsc) { | ||
ret = request_irq(msgq->tx_ghrsc->irq, gh_msgq_tx_irq_handler, 0, "gh_msgq_tx", | ||
msgq); | ||
if (ret) | ||
goto err_chans; | ||
} | ||
|
||
if (msgq->rx_ghrsc) { | ||
ret = request_threaded_irq(msgq->rx_ghrsc->irq, NULL, gh_msgq_rx_irq_handler, | ||
IRQF_ONESHOT, "gh_msgq_rx", msgq); | ||
if (ret) | ||
goto err_tx_irq; | ||
} | ||
|
||
tasklet_setup(&msgq->txdone_tasklet, gh_msgq_txdone_tasklet); | ||
|
||
ret = mbox_controller_register(&msgq->mbox); | ||
if (ret) | ||
goto err_rx_irq; | ||
|
||
ret = mbox_bind_client(gh_msgq_chan(msgq), cl); | ||
if (ret) | ||
goto err_mbox; | ||
|
||
return 0; | ||
err_mbox: | ||
mbox_controller_unregister(&msgq->mbox); | ||
err_rx_irq: | ||
if (msgq->rx_ghrsc) | ||
free_irq(msgq->rx_ghrsc->irq, msgq); | ||
err_tx_irq: | ||
if (msgq->tx_ghrsc) | ||
free_irq(msgq->tx_ghrsc->irq, msgq); | ||
err_chans: | ||
kfree(msgq->mbox.chans); | ||
return ret; | ||
} | ||
EXPORT_SYMBOL_GPL(gh_msgq_init); | ||
|
||
void gh_msgq_remove(struct gh_msgq *msgq) | ||
{ | ||
mbox_controller_unregister(&msgq->mbox); | ||
|
||
if (msgq->rx_ghrsc) | ||
free_irq(msgq->rx_ghrsc->irq, msgq); | ||
|
||
if (msgq->tx_ghrsc) | ||
free_irq(msgq->tx_ghrsc->irq, msgq); | ||
|
||
kfree(msgq->mbox.chans); | ||
} | ||
EXPORT_SYMBOL_GPL(gh_msgq_remove); | ||
|
||
MODULE_LICENSE("GPL"); | ||
MODULE_DESCRIPTION("Gunyah Message Queue Driver"); |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters