firmware: tegra: Changes for v5.1-rc1
These changes add support for BPMP on Tegra210. -----BEGIN PGP SIGNATURE----- iQJHBAABCAAxFiEEiOrDCAFJzPfAjcif3SOs138+s6EFAlxdmJ4THHRyZWRpbmdA bnZpZGlhLmNvbQAKCRDdI6zXfz6zoUNjEACJz0nXjTDHmlw/kWrOyVDK2B0Jmvno toVi0CvJxER6itaVPHnxayQBl/a76owF+h4HbXjuvD2fAj8vfhjNYiwed5NxvMGO lbP4Q6MhKoGzqIiZIubWNEQXLNK9gRrPULc1GuTuVKwIUPhUwKFgtHkFi6balVR0 lpnNEU1V070LPbW1I4oxG6fdntJO+KMVoBWcPfCsnMQmEZOG/CqQhbYRPKojDsaO bb5FC3epffYBPIfJyvJy4XrGX6VOD4gC5KDhnDyIe4Hby4PsTzQGKcnp2b4OVssG nRON9X72o1i4uOdnUNkJnd6UGOL9Xn8zU9y2al6hRnx04+Sp1MHVSOwxI5HgkK7H PtFJe4u639MbsP6J1RLfKMpbLHdOEU7xE26MaQz7CdHd57L11szRgv3HcdsuCpmd a53djDTR0B2U9FzKI8ohp/cGr2l4Nc6Wlz2iVqxwTxyqXhE8NToIc56/gBQsIBbe qotxZumjjjseaQAHlykyaPG1DcRPz71Z+FXnFyG7soncO0ksbIO42b1Ms2jz+v7D ukHN193NLPfPB7EZCAsVnD+f1lIekrV+uWkTM9JoMgLkbxGSYKZS43hXO2QSa8Y4 H3eDOGjV2PFL74Lzv2rW7dtMiM5dx5ewie/pX7J+aIOwnBlN65Pexs7zm0NREjtQ 1qrmUTtiDFnZng== =8HHq -----END PGP SIGNATURE----- Merge tag 'tegra-for-5.1-firmware' of git://git.kernel.org/pub/scm/linux/kernel/git/tegra/linux into arm/drivers firmware: tegra: Changes for v5.1-rc1 These changes add support for BPMP on Tegra210. * tag 'tegra-for-5.1-firmware' of git://git.kernel.org/pub/scm/linux/kernel/git/tegra/linux: firmware/tegra: Enable Tegra186 BPMP support on Tegra194 firmware: tegra: Conditionally support SoC generations firmware: tegra: bpmp-tegra186: Remove unused includes firmware: tegra: add bpmp driver for Tegra210 firmware: tegra: Refactor BPMP driver firmware: tegra: Reword messaging terminology Signed-off-by: Arnd Bergmann <arnd@arndb.de>
This commit is contained in:
Arnd Bergmann
commit
f73e22d621
|
|
@ -1,4 +1,7 @@
|
|||
tegra-bpmp-y = bpmp.o
|
||||
tegra-bpmp-$(CONFIG_ARCH_TEGRA_210_SOC) += bpmp-tegra210.o
|
||||
tegra-bpmp-$(CONFIG_ARCH_TEGRA_186_SOC) += bpmp-tegra186.o
|
||||
tegra-bpmp-$(CONFIG_ARCH_TEGRA_194_SOC) += bpmp-tegra186.o
|
||||
tegra-bpmp-$(CONFIG_DEBUG_FS) += bpmp-debugfs.o
|
||||
obj-$(CONFIG_TEGRA_BPMP) += tegra-bpmp.o
|
||||
obj-$(CONFIG_TEGRA_IVC) += ivc.o
|
||||
|
|
|
|||
|
|
@ -0,0 +1,34 @@
|
|||
/* SPDX-License-Identifier: GPL-2.0 */
|
||||
/*
|
||||
* Copyright (c) 2018, NVIDIA CORPORATION.
|
||||
*/
|
||||
|
||||
#ifndef __FIRMWARE_TEGRA_BPMP_PRIVATE_H
|
||||
#define __FIRMWARE_TEGRA_BPMP_PRIVATE_H
|
||||
|
||||
#include <soc/tegra/bpmp.h>
|
||||
|
||||
struct tegra_bpmp_ops {
|
||||
int (*init)(struct tegra_bpmp *bpmp);
|
||||
void (*deinit)(struct tegra_bpmp *bpmp);
|
||||
bool (*is_response_ready)(struct tegra_bpmp_channel *channel);
|
||||
bool (*is_request_ready)(struct tegra_bpmp_channel *channel);
|
||||
int (*ack_response)(struct tegra_bpmp_channel *channel);
|
||||
int (*ack_request)(struct tegra_bpmp_channel *channel);
|
||||
bool (*is_response_channel_free)(struct tegra_bpmp_channel *channel);
|
||||
bool (*is_request_channel_free)(struct tegra_bpmp_channel *channel);
|
||||
int (*post_response)(struct tegra_bpmp_channel *channel);
|
||||
int (*post_request)(struct tegra_bpmp_channel *channel);
|
||||
int (*ring_doorbell)(struct tegra_bpmp *bpmp);
|
||||
int (*resume)(struct tegra_bpmp *bpmp);
|
||||
};
|
||||
|
||||
#if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \
|
||||
IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC)
|
||||
extern const struct tegra_bpmp_ops tegra186_bpmp_ops;
|
||||
#endif
|
||||
#if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC)
|
||||
extern const struct tegra_bpmp_ops tegra210_bpmp_ops;
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,305 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/*
|
||||
* Copyright (c) 2018, NVIDIA CORPORATION.
|
||||
*/
|
||||
|
||||
#include <linux/genalloc.h>
|
||||
#include <linux/mailbox_client.h>
|
||||
#include <linux/platform_device.h>
|
||||
|
||||
#include <soc/tegra/bpmp.h>
|
||||
#include <soc/tegra/bpmp-abi.h>
|
||||
#include <soc/tegra/ivc.h>
|
||||
|
||||
#include "bpmp-private.h"
|
||||
|
||||
struct tegra186_bpmp {
|
||||
struct tegra_bpmp *parent;
|
||||
|
||||
struct {
|
||||
struct gen_pool *pool;
|
||||
dma_addr_t phys;
|
||||
void *virt;
|
||||
} tx, rx;
|
||||
|
||||
struct {
|
||||
struct mbox_client client;
|
||||
struct mbox_chan *channel;
|
||||
} mbox;
|
||||
};
|
||||
|
||||
static inline struct tegra_bpmp *
|
||||
mbox_client_to_bpmp(struct mbox_client *client)
|
||||
{
|
||||
struct tegra186_bpmp *priv;
|
||||
|
||||
priv = container_of(client, struct tegra186_bpmp, mbox.client);
|
||||
|
||||
return priv->parent;
|
||||
}
|
||||
|
||||
static bool tegra186_bpmp_is_message_ready(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
void *frame;
|
||||
|
||||
frame = tegra_ivc_read_get_next_frame(channel->ivc);
|
||||
if (IS_ERR(frame)) {
|
||||
channel->ib = NULL;
|
||||
return false;
|
||||
}
|
||||
|
||||
channel->ib = frame;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static bool tegra186_bpmp_is_channel_free(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
void *frame;
|
||||
|
||||
frame = tegra_ivc_write_get_next_frame(channel->ivc);
|
||||
if (IS_ERR(frame)) {
|
||||
channel->ob = NULL;
|
||||
return false;
|
||||
}
|
||||
|
||||
channel->ob = frame;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static int tegra186_bpmp_ack_message(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
return tegra_ivc_read_advance(channel->ivc);
|
||||
}
|
||||
|
||||
static int tegra186_bpmp_post_message(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
return tegra_ivc_write_advance(channel->ivc);
|
||||
}
|
||||
|
||||
static int tegra186_bpmp_ring_doorbell(struct tegra_bpmp *bpmp)
|
||||
{
|
||||
struct tegra186_bpmp *priv = bpmp->priv;
|
||||
int err;
|
||||
|
||||
err = mbox_send_message(priv->mbox.channel, NULL);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
mbox_client_txdone(priv->mbox.channel, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void tegra186_bpmp_ivc_notify(struct tegra_ivc *ivc, void *data)
|
||||
{
|
||||
struct tegra_bpmp *bpmp = data;
|
||||
struct tegra186_bpmp *priv = bpmp->priv;
|
||||
|
||||
if (WARN_ON(priv->mbox.channel == NULL))
|
||||
return;
|
||||
|
||||
tegra186_bpmp_ring_doorbell(bpmp);
|
||||
}
|
||||
|
||||
static int tegra186_bpmp_channel_init(struct tegra_bpmp_channel *channel,
|
||||
struct tegra_bpmp *bpmp,
|
||||
unsigned int index)
|
||||
{
|
||||
struct tegra186_bpmp *priv = bpmp->priv;
|
||||
size_t message_size, queue_size;
|
||||
unsigned int offset;
|
||||
int err;
|
||||
|
||||
channel->ivc = devm_kzalloc(bpmp->dev, sizeof(*channel->ivc),
|
||||
GFP_KERNEL);
|
||||
if (!channel->ivc)
|
||||
return -ENOMEM;
|
||||
|
||||
message_size = tegra_ivc_align(MSG_MIN_SZ);
|
||||
queue_size = tegra_ivc_total_queue_size(message_size);
|
||||
offset = queue_size * index;
|
||||
|
||||
err = tegra_ivc_init(channel->ivc, NULL,
|
||||
priv->rx.virt + offset, priv->rx.phys + offset,
|
||||
priv->tx.virt + offset, priv->tx.phys + offset,
|
||||
1, message_size, tegra186_bpmp_ivc_notify,
|
||||
bpmp);
|
||||
if (err < 0) {
|
||||
dev_err(bpmp->dev, "failed to setup IVC for channel %u: %d\n",
|
||||
index, err);
|
||||
return err;
|
||||
}
|
||||
|
||||
init_completion(&channel->completion);
|
||||
channel->bpmp = bpmp;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void tegra186_bpmp_channel_reset(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
/* reset the channel state */
|
||||
tegra_ivc_reset(channel->ivc);
|
||||
|
||||
/* sync the channel state with BPMP */
|
||||
while (tegra_ivc_notified(channel->ivc))
|
||||
;
|
||||
}
|
||||
|
||||
static void tegra186_bpmp_channel_cleanup(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
tegra_ivc_cleanup(channel->ivc);
|
||||
}
|
||||
|
||||
static void mbox_handle_rx(struct mbox_client *client, void *data)
|
||||
{
|
||||
struct tegra_bpmp *bpmp = mbox_client_to_bpmp(client);
|
||||
|
||||
tegra_bpmp_handle_rx(bpmp);
|
||||
}
|
||||
|
||||
static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)
|
||||
{
|
||||
struct tegra186_bpmp *priv;
|
||||
unsigned int i;
|
||||
int err;
|
||||
|
||||
priv = devm_kzalloc(bpmp->dev, sizeof(*priv), GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
bpmp->priv = priv;
|
||||
priv->parent = bpmp;
|
||||
|
||||
priv->tx.pool = of_gen_pool_get(bpmp->dev->of_node, "shmem", 0);
|
||||
if (!priv->tx.pool) {
|
||||
dev_err(bpmp->dev, "TX shmem pool not found\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
priv->tx.virt = gen_pool_dma_alloc(priv->tx.pool, 4096, &priv->tx.phys);
|
||||
if (!priv->tx.virt) {
|
||||
dev_err(bpmp->dev, "failed to allocate from TX pool\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
priv->rx.pool = of_gen_pool_get(bpmp->dev->of_node, "shmem", 1);
|
||||
if (!priv->rx.pool) {
|
||||
dev_err(bpmp->dev, "RX shmem pool not found\n");
|
||||
err = -ENOMEM;
|
||||
goto free_tx;
|
||||
}
|
||||
|
||||
priv->rx.virt = gen_pool_dma_alloc(priv->rx.pool, 4096, &priv->rx.phys);
|
||||
if (!priv->rx.virt) {
|
||||
dev_err(bpmp->dev, "failed to allocate from RX pool\n");
|
||||
err = -ENOMEM;
|
||||
goto free_tx;
|
||||
}
|
||||
|
||||
err = tegra186_bpmp_channel_init(bpmp->tx_channel, bpmp,
|
||||
bpmp->soc->channels.cpu_tx.offset);
|
||||
if (err < 0)
|
||||
goto free_rx;
|
||||
|
||||
err = tegra186_bpmp_channel_init(bpmp->rx_channel, bpmp,
|
||||
bpmp->soc->channels.cpu_rx.offset);
|
||||
if (err < 0)
|
||||
goto cleanup_tx_channel;
|
||||
|
||||
for (i = 0; i < bpmp->threaded.count; i++) {
|
||||
unsigned int index = bpmp->soc->channels.thread.offset + i;
|
||||
|
||||
err = tegra186_bpmp_channel_init(&bpmp->threaded_channels[i],
|
||||
bpmp, index);
|
||||
if (err < 0)
|
||||
goto cleanup_channels;
|
||||
}
|
||||
|
||||
/* mbox registration */
|
||||
priv->mbox.client.dev = bpmp->dev;
|
||||
priv->mbox.client.rx_callback = mbox_handle_rx;
|
||||
priv->mbox.client.tx_block = false;
|
||||
priv->mbox.client.knows_txdone = false;
|
||||
|
||||
priv->mbox.channel = mbox_request_channel(&priv->mbox.client, 0);
|
||||
if (IS_ERR(priv->mbox.channel)) {
|
||||
err = PTR_ERR(priv->mbox.channel);
|
||||
dev_err(bpmp->dev, "failed to get HSP mailbox: %d\n", err);
|
||||
goto cleanup_channels;
|
||||
}
|
||||
|
||||
tegra186_bpmp_channel_reset(bpmp->tx_channel);
|
||||
tegra186_bpmp_channel_reset(bpmp->rx_channel);
|
||||
|
||||
for (i = 0; i < bpmp->threaded.count; i++)
|
||||
tegra186_bpmp_channel_reset(&bpmp->threaded_channels[i]);
|
||||
|
||||
return 0;
|
||||
|
||||
cleanup_channels:
|
||||
for (i = 0; i < bpmp->threaded.count; i++) {
|
||||
if (!bpmp->threaded_channels[i].bpmp)
|
||||
continue;
|
||||
|
||||
tegra186_bpmp_channel_cleanup(&bpmp->threaded_channels[i]);
|
||||
}
|
||||
|
||||
tegra186_bpmp_channel_cleanup(bpmp->rx_channel);
|
||||
cleanup_tx_channel:
|
||||
tegra186_bpmp_channel_cleanup(bpmp->tx_channel);
|
||||
free_rx:
|
||||
gen_pool_free(priv->rx.pool, (unsigned long)priv->rx.virt, 4096);
|
||||
free_tx:
|
||||
gen_pool_free(priv->tx.pool, (unsigned long)priv->tx.virt, 4096);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
static void tegra186_bpmp_deinit(struct tegra_bpmp *bpmp)
|
||||
{
|
||||
struct tegra186_bpmp *priv = bpmp->priv;
|
||||
unsigned int i;
|
||||
|
||||
mbox_free_channel(priv->mbox.channel);
|
||||
|
||||
for (i = 0; i < bpmp->threaded.count; i++)
|
||||
tegra186_bpmp_channel_cleanup(&bpmp->threaded_channels[i]);
|
||||
|
||||
tegra186_bpmp_channel_cleanup(bpmp->rx_channel);
|
||||
tegra186_bpmp_channel_cleanup(bpmp->tx_channel);
|
||||
|
||||
gen_pool_free(priv->rx.pool, (unsigned long)priv->rx.virt, 4096);
|
||||
gen_pool_free(priv->tx.pool, (unsigned long)priv->tx.virt, 4096);
|
||||
}
|
||||
|
||||
static int tegra186_bpmp_resume(struct tegra_bpmp *bpmp)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
/* reset message channels */
|
||||
tegra186_bpmp_channel_reset(bpmp->tx_channel);
|
||||
tegra186_bpmp_channel_reset(bpmp->rx_channel);
|
||||
|
||||
for (i = 0; i < bpmp->threaded.count; i++)
|
||||
tegra186_bpmp_channel_reset(&bpmp->threaded_channels[i]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
const struct tegra_bpmp_ops tegra186_bpmp_ops = {
|
||||
.init = tegra186_bpmp_init,
|
||||
.deinit = tegra186_bpmp_deinit,
|
||||
.is_response_ready = tegra186_bpmp_is_message_ready,
|
||||
.is_request_ready = tegra186_bpmp_is_message_ready,
|
||||
.ack_response = tegra186_bpmp_ack_message,
|
||||
.ack_request = tegra186_bpmp_ack_message,
|
||||
.is_response_channel_free = tegra186_bpmp_is_channel_free,
|
||||
.is_request_channel_free = tegra186_bpmp_is_channel_free,
|
||||
.post_response = tegra186_bpmp_post_message,
|
||||
.post_request = tegra186_bpmp_post_message,
|
||||
.ring_doorbell = tegra186_bpmp_ring_doorbell,
|
||||
.resume = tegra186_bpmp_resume,
|
||||
};
|
||||
|
|
@ -0,0 +1,243 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/*
|
||||
* Copyright (c) 2018, NVIDIA CORPORATION.
|
||||
*/
|
||||
|
||||
#include <linux/interrupt.h>
|
||||
#include <linux/irq.h>
|
||||
#include <linux/io.h>
|
||||
#include <linux/of.h>
|
||||
#include <linux/platform_device.h>
|
||||
|
||||
#include <soc/tegra/bpmp.h>
|
||||
|
||||
#include "bpmp-private.h"
|
||||
|
||||
#define TRIGGER_OFFSET 0x000
|
||||
#define RESULT_OFFSET(id) (0xc00 + id * 4)
|
||||
#define TRIGGER_ID_SHIFT 16
|
||||
#define TRIGGER_CMD_GET 4
|
||||
|
||||
#define STA_OFFSET 0
|
||||
#define SET_OFFSET 4
|
||||
#define CLR_OFFSET 8
|
||||
|
||||
#define CH_MASK(ch) (0x3 << ((ch) * 2))
|
||||
#define SL_SIGL(ch) (0x0 << ((ch) * 2))
|
||||
#define SL_QUED(ch) (0x1 << ((ch) * 2))
|
||||
#define MA_FREE(ch) (0x2 << ((ch) * 2))
|
||||
#define MA_ACKD(ch) (0x3 << ((ch) * 2))
|
||||
|
||||
struct tegra210_bpmp {
|
||||
void __iomem *atomics;
|
||||
void __iomem *arb_sema;
|
||||
struct irq_data *tx_irq_data;
|
||||
};
|
||||
|
||||
static u32 bpmp_channel_status(struct tegra_bpmp *bpmp, unsigned int index)
|
||||
{
|
||||
struct tegra210_bpmp *priv = bpmp->priv;
|
||||
|
||||
return __raw_readl(priv->arb_sema + STA_OFFSET) & CH_MASK(index);
|
||||
}
|
||||
|
||||
static bool tegra210_bpmp_is_response_ready(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
unsigned int index = channel->index;
|
||||
|
||||
return bpmp_channel_status(channel->bpmp, index) == MA_ACKD(index);
|
||||
}
|
||||
|
||||
static bool tegra210_bpmp_is_request_ready(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
unsigned int index = channel->index;
|
||||
|
||||
return bpmp_channel_status(channel->bpmp, index) == SL_SIGL(index);
|
||||
}
|
||||
|
||||
static bool
|
||||
tegra210_bpmp_is_request_channel_free(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
unsigned int index = channel->index;
|
||||
|
||||
return bpmp_channel_status(channel->bpmp, index) == MA_FREE(index);
|
||||
}
|
||||
|
||||
static bool
|
||||
tegra210_bpmp_is_response_channel_free(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
unsigned int index = channel->index;
|
||||
|
||||
return bpmp_channel_status(channel->bpmp, index) == SL_QUED(index);
|
||||
}
|
||||
|
||||
static int tegra210_bpmp_post_request(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
struct tegra210_bpmp *priv = channel->bpmp->priv;
|
||||
|
||||
__raw_writel(CH_MASK(channel->index), priv->arb_sema + CLR_OFFSET);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tegra210_bpmp_post_response(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
struct tegra210_bpmp *priv = channel->bpmp->priv;
|
||||
|
||||
__raw_writel(MA_ACKD(channel->index), priv->arb_sema + SET_OFFSET);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tegra210_bpmp_ack_response(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
struct tegra210_bpmp *priv = channel->bpmp->priv;
|
||||
|
||||
__raw_writel(MA_ACKD(channel->index) ^ MA_FREE(channel->index),
|
||||
priv->arb_sema + CLR_OFFSET);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tegra210_bpmp_ack_request(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
struct tegra210_bpmp *priv = channel->bpmp->priv;
|
||||
|
||||
__raw_writel(SL_QUED(channel->index), priv->arb_sema + SET_OFFSET);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tegra210_bpmp_ring_doorbell(struct tegra_bpmp *bpmp)
|
||||
{
|
||||
struct tegra210_bpmp *priv = bpmp->priv;
|
||||
struct irq_data *irq_data = priv->tx_irq_data;
|
||||
|
||||
/*
|
||||
* Tegra Legacy Interrupt Controller (LIC) is used to notify BPMP of
|
||||
* available messages
|
||||
*/
|
||||
if (irq_data->chip->irq_retrigger)
|
||||
return irq_data->chip->irq_retrigger(irq_data);
|
||||
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
static irqreturn_t rx_irq(int irq, void *data)
|
||||
{
|
||||
struct tegra_bpmp *bpmp = data;
|
||||
|
||||
tegra_bpmp_handle_rx(bpmp);
|
||||
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
static int tegra210_bpmp_channel_init(struct tegra_bpmp_channel *channel,
|
||||
struct tegra_bpmp *bpmp,
|
||||
unsigned int index)
|
||||
{
|
||||
struct tegra210_bpmp *priv = bpmp->priv;
|
||||
u32 address;
|
||||
void *p;
|
||||
|
||||
/* Retrieve channel base address from BPMP */
|
||||
writel(index << TRIGGER_ID_SHIFT | TRIGGER_CMD_GET,
|
||||
priv->atomics + TRIGGER_OFFSET);
|
||||
address = readl(priv->atomics + RESULT_OFFSET(index));
|
||||
|
||||
p = devm_ioremap(bpmp->dev, address, 0x80);
|
||||
if (!p)
|
||||
return -ENOMEM;
|
||||
|
||||
channel->ib = p;
|
||||
channel->ob = p;
|
||||
channel->index = index;
|
||||
init_completion(&channel->completion);
|
||||
channel->bpmp = bpmp;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int tegra210_bpmp_init(struct tegra_bpmp *bpmp)
|
||||
{
|
||||
struct platform_device *pdev = to_platform_device(bpmp->dev);
|
||||
struct tegra210_bpmp *priv;
|
||||
struct resource *res;
|
||||
unsigned int i;
|
||||
int err;
|
||||
|
||||
priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
|
||||
if (!priv)
|
||||
return -ENOMEM;
|
||||
|
||||
bpmp->priv = priv;
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
||||
priv->atomics = devm_ioremap_resource(&pdev->dev, res);
|
||||
if (IS_ERR(priv->atomics))
|
||||
return PTR_ERR(priv->atomics);
|
||||
|
||||
res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
|
||||
priv->arb_sema = devm_ioremap_resource(&pdev->dev, res);
|
||||
if (IS_ERR(priv->arb_sema))
|
||||
return PTR_ERR(priv->arb_sema);
|
||||
|
||||
err = tegra210_bpmp_channel_init(bpmp->tx_channel, bpmp,
|
||||
bpmp->soc->channels.cpu_tx.offset);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
err = tegra210_bpmp_channel_init(bpmp->rx_channel, bpmp,
|
||||
bpmp->soc->channels.cpu_rx.offset);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
for (i = 0; i < bpmp->threaded.count; i++) {
|
||||
unsigned int index = bpmp->soc->channels.thread.offset + i;
|
||||
|
||||
err = tegra210_bpmp_channel_init(&bpmp->threaded_channels[i],
|
||||
bpmp, index);
|
||||
if (err < 0)
|
||||
return err;
|
||||
}
|
||||
|
||||
err = platform_get_irq_byname(pdev, "tx");
|
||||
if (err < 0) {
|
||||
dev_err(&pdev->dev, "failed to get TX IRQ: %d\n", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
priv->tx_irq_data = irq_get_irq_data(err);
|
||||
if (!priv->tx_irq_data) {
|
||||
dev_err(&pdev->dev, "failed to get IRQ data for TX IRQ\n");
|
||||
return err;
|
||||
}
|
||||
|
||||
err = platform_get_irq_byname(pdev, "rx");
|
||||
if (err < 0) {
|
||||
dev_err(&pdev->dev, "failed to get rx IRQ: %d\n", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
err = devm_request_irq(&pdev->dev, err, rx_irq,
|
||||
IRQF_NO_SUSPEND, dev_name(&pdev->dev), bpmp);
|
||||
if (err < 0) {
|
||||
dev_err(&pdev->dev, "failed to request IRQ: %d\n", err);
|
||||
return err;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
const struct tegra_bpmp_ops tegra210_bpmp_ops = {
|
||||
.init = tegra210_bpmp_init,
|
||||
.is_response_ready = tegra210_bpmp_is_response_ready,
|
||||
.is_request_ready = tegra210_bpmp_is_request_ready,
|
||||
.ack_response = tegra210_bpmp_ack_response,
|
||||
.ack_request = tegra210_bpmp_ack_request,
|
||||
.is_response_channel_free = tegra210_bpmp_is_response_channel_free,
|
||||
.is_request_channel_free = tegra210_bpmp_is_request_channel_free,
|
||||
.post_response = tegra210_bpmp_post_response,
|
||||
.post_request = tegra210_bpmp_post_request,
|
||||
.ring_doorbell = tegra210_bpmp_ring_doorbell,
|
||||
};
|
||||
|
|
@ -26,6 +26,8 @@
|
|||
#include <soc/tegra/bpmp-abi.h>
|
||||
#include <soc/tegra/ivc.h>
|
||||
|
||||
#include "bpmp-private.h"
|
||||
|
||||
#define MSG_ACK BIT(0)
|
||||
#define MSG_RING BIT(1)
|
||||
#define TAG_SZ 32
|
||||
|
|
@ -36,6 +38,14 @@ mbox_client_to_bpmp(struct mbox_client *client)
|
|||
return container_of(client, struct tegra_bpmp, mbox.client);
|
||||
}
|
||||
|
||||
static inline const struct tegra_bpmp_ops *
|
||||
channel_to_ops(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
struct tegra_bpmp *bpmp = channel->bpmp;
|
||||
|
||||
return bpmp->soc->ops;
|
||||
}
|
||||
|
||||
struct tegra_bpmp *tegra_bpmp_get(struct device *dev)
|
||||
{
|
||||
struct platform_device *pdev;
|
||||
|
|
@ -96,22 +106,21 @@ static bool tegra_bpmp_message_valid(const struct tegra_bpmp_message *msg)
|
|||
(msg->rx.size == 0 || msg->rx.data);
|
||||
}
|
||||
|
||||
static bool tegra_bpmp_master_acked(struct tegra_bpmp_channel *channel)
|
||||
static bool tegra_bpmp_is_response_ready(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
void *frame;
|
||||
const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
|
||||
|
||||
frame = tegra_ivc_read_get_next_frame(channel->ivc);
|
||||
if (IS_ERR(frame)) {
|
||||
channel->ib = NULL;
|
||||
return false;
|
||||
}
|
||||
|
||||
channel->ib = frame;
|
||||
|
||||
return true;
|
||||
return ops->is_response_ready(channel);
|
||||
}
|
||||
|
||||
static int tegra_bpmp_wait_ack(struct tegra_bpmp_channel *channel)
|
||||
static bool tegra_bpmp_is_request_ready(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
|
||||
|
||||
return ops->is_request_ready(channel);
|
||||
}
|
||||
|
||||
static int tegra_bpmp_wait_response(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
unsigned long timeout = channel->bpmp->soc->channels.cpu_tx.timeout;
|
||||
ktime_t end;
|
||||
|
|
@ -119,29 +128,45 @@ static int tegra_bpmp_wait_ack(struct tegra_bpmp_channel *channel)
|
|||
end = ktime_add_us(ktime_get(), timeout);
|
||||
|
||||
do {
|
||||
if (tegra_bpmp_master_acked(channel))
|
||||
if (tegra_bpmp_is_response_ready(channel))
|
||||
return 0;
|
||||
} while (ktime_before(ktime_get(), end));
|
||||
|
||||
return -ETIMEDOUT;
|
||||
}
|
||||
|
||||
static bool tegra_bpmp_master_free(struct tegra_bpmp_channel *channel)
|
||||
static int tegra_bpmp_ack_response(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
void *frame;
|
||||
const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
|
||||
|
||||
frame = tegra_ivc_write_get_next_frame(channel->ivc);
|
||||
if (IS_ERR(frame)) {
|
||||
channel->ob = NULL;
|
||||
return false;
|
||||
}
|
||||
|
||||
channel->ob = frame;
|
||||
|
||||
return true;
|
||||
return ops->ack_response(channel);
|
||||
}
|
||||
|
||||
static int tegra_bpmp_wait_master_free(struct tegra_bpmp_channel *channel)
|
||||
static int tegra_bpmp_ack_request(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
|
||||
|
||||
return ops->ack_request(channel);
|
||||
}
|
||||
|
||||
static bool
|
||||
tegra_bpmp_is_request_channel_free(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
|
||||
|
||||
return ops->is_request_channel_free(channel);
|
||||
}
|
||||
|
||||
static bool
|
||||
tegra_bpmp_is_response_channel_free(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
|
||||
|
||||
return ops->is_response_channel_free(channel);
|
||||
}
|
||||
|
||||
static int
|
||||
tegra_bpmp_wait_request_channel_free(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
unsigned long timeout = channel->bpmp->soc->channels.cpu_tx.timeout;
|
||||
ktime_t start, now;
|
||||
|
|
@ -149,7 +174,7 @@ static int tegra_bpmp_wait_master_free(struct tegra_bpmp_channel *channel)
|
|||
start = ns_to_ktime(local_clock());
|
||||
|
||||
do {
|
||||
if (tegra_bpmp_master_free(channel))
|
||||
if (tegra_bpmp_is_request_channel_free(channel))
|
||||
return 0;
|
||||
|
||||
now = ns_to_ktime(local_clock());
|
||||
|
|
@ -158,6 +183,25 @@ static int tegra_bpmp_wait_master_free(struct tegra_bpmp_channel *channel)
|
|||
return -ETIMEDOUT;
|
||||
}
|
||||
|
||||
static int tegra_bpmp_post_request(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
|
||||
|
||||
return ops->post_request(channel);
|
||||
}
|
||||
|
||||
static int tegra_bpmp_post_response(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
const struct tegra_bpmp_ops *ops = channel_to_ops(channel);
|
||||
|
||||
return ops->post_response(channel);
|
||||
}
|
||||
|
||||
static int tegra_bpmp_ring_doorbell(struct tegra_bpmp *bpmp)
|
||||
{
|
||||
return bpmp->soc->ops->ring_doorbell(bpmp);
|
||||
}
|
||||
|
||||
static ssize_t __tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,
|
||||
void *data, size_t size, int *ret)
|
||||
{
|
||||
|
|
@ -166,7 +210,7 @@ static ssize_t __tegra_bpmp_channel_read(struct tegra_bpmp_channel *channel,
|
|||
if (data && size > 0)
|
||||
memcpy(data, channel->ib->data, size);
|
||||
|
||||
err = tegra_ivc_read_advance(channel->ivc);
|
||||
err = tegra_bpmp_ack_response(channel);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
|
|
@ -210,7 +254,7 @@ static ssize_t __tegra_bpmp_channel_write(struct tegra_bpmp_channel *channel,
|
|||
if (data && size > 0)
|
||||
memcpy(channel->ob->data, data, size);
|
||||
|
||||
return tegra_ivc_write_advance(channel->ivc);
|
||||
return tegra_bpmp_post_request(channel);
|
||||
}
|
||||
|
||||
static struct tegra_bpmp_channel *
|
||||
|
|
@ -238,7 +282,7 @@ tegra_bpmp_write_threaded(struct tegra_bpmp *bpmp, unsigned int mrq,
|
|||
|
||||
channel = &bpmp->threaded_channels[index];
|
||||
|
||||
if (!tegra_bpmp_master_free(channel)) {
|
||||
if (!tegra_bpmp_is_request_channel_free(channel)) {
|
||||
err = -EBUSY;
|
||||
goto unlock;
|
||||
}
|
||||
|
|
@ -270,7 +314,7 @@ static ssize_t tegra_bpmp_channel_write(struct tegra_bpmp_channel *channel,
|
|||
{
|
||||
int err;
|
||||
|
||||
err = tegra_bpmp_wait_master_free(channel);
|
||||
err = tegra_bpmp_wait_request_channel_free(channel);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
|
|
@ -302,13 +346,11 @@ int tegra_bpmp_transfer_atomic(struct tegra_bpmp *bpmp,
|
|||
|
||||
spin_unlock(&bpmp->atomic_tx_lock);
|
||||
|
||||
err = mbox_send_message(bpmp->mbox.channel, NULL);
|
||||
err = tegra_bpmp_ring_doorbell(bpmp);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
mbox_client_txdone(bpmp->mbox.channel, 0);
|
||||
|
||||
err = tegra_bpmp_wait_ack(channel);
|
||||
err = tegra_bpmp_wait_response(channel);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
|
|
@ -335,12 +377,10 @@ int tegra_bpmp_transfer(struct tegra_bpmp *bpmp,
|
|||
if (IS_ERR(channel))
|
||||
return PTR_ERR(channel);
|
||||
|
||||
err = mbox_send_message(bpmp->mbox.channel, NULL);
|
||||
err = tegra_bpmp_ring_doorbell(bpmp);
|
||||
if (err < 0)
|
||||
return err;
|
||||
|
||||
mbox_client_txdone(bpmp->mbox.channel, 0);
|
||||
|
||||
timeout = usecs_to_jiffies(bpmp->soc->channels.thread.timeout);
|
||||
|
||||
err = wait_for_completion_timeout(&channel->completion, timeout);
|
||||
|
|
@ -369,38 +409,34 @@ void tegra_bpmp_mrq_return(struct tegra_bpmp_channel *channel, int code,
|
|||
{
|
||||
unsigned long flags = channel->ib->flags;
|
||||
struct tegra_bpmp *bpmp = channel->bpmp;
|
||||
struct tegra_bpmp_mb_data *frame;
|
||||
int err;
|
||||
|
||||
if (WARN_ON(size > MSG_DATA_MIN_SZ))
|
||||
return;
|
||||
|
||||
err = tegra_ivc_read_advance(channel->ivc);
|
||||
err = tegra_bpmp_ack_request(channel);
|
||||
if (WARN_ON(err < 0))
|
||||
return;
|
||||
|
||||
if ((flags & MSG_ACK) == 0)
|
||||
return;
|
||||
|
||||
frame = tegra_ivc_write_get_next_frame(channel->ivc);
|
||||
if (WARN_ON(IS_ERR(frame)))
|
||||
if (WARN_ON(!tegra_bpmp_is_response_channel_free(channel)))
|
||||
return;
|
||||
|
||||
frame->code = code;
|
||||
channel->ob->code = code;
|
||||
|
||||
if (data && size > 0)
|
||||
memcpy(frame->data, data, size);
|
||||
memcpy(channel->ob->data, data, size);
|
||||
|
||||
err = tegra_ivc_write_advance(channel->ivc);
|
||||
err = tegra_bpmp_post_response(channel);
|
||||
if (WARN_ON(err < 0))
|
||||
return;
|
||||
|
||||
if (flags & MSG_RING) {
|
||||
err = mbox_send_message(bpmp->mbox.channel, NULL);
|
||||
err = tegra_bpmp_ring_doorbell(bpmp);
|
||||
if (WARN_ON(err < 0))
|
||||
return;
|
||||
|
||||
mbox_client_txdone(bpmp->mbox.channel, 0);
|
||||
}
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(tegra_bpmp_mrq_return);
|
||||
|
|
@ -627,9 +663,8 @@ static void tegra_bpmp_channel_signal(struct tegra_bpmp_channel *channel)
|
|||
complete(&channel->completion);
|
||||
}
|
||||
|
||||
static void tegra_bpmp_handle_rx(struct mbox_client *client, void *data)
|
||||
void tegra_bpmp_handle_rx(struct tegra_bpmp *bpmp)
|
||||
{
|
||||
struct tegra_bpmp *bpmp = mbox_client_to_bpmp(client);
|
||||
struct tegra_bpmp_channel *channel;
|
||||
unsigned int i, count;
|
||||
unsigned long *busy;
|
||||
|
|
@ -638,7 +673,7 @@ static void tegra_bpmp_handle_rx(struct mbox_client *client, void *data)
|
|||
count = bpmp->soc->channels.thread.count;
|
||||
busy = bpmp->threaded.busy;
|
||||
|
||||
if (tegra_bpmp_master_acked(channel))
|
||||
if (tegra_bpmp_is_request_ready(channel))
|
||||
tegra_bpmp_handle_mrq(bpmp, channel->ib->code, channel);
|
||||
|
||||
spin_lock(&bpmp->lock);
|
||||
|
|
@ -648,7 +683,7 @@ static void tegra_bpmp_handle_rx(struct mbox_client *client, void *data)
|
|||
|
||||
channel = &bpmp->threaded_channels[i];
|
||||
|
||||
if (tegra_bpmp_master_acked(channel)) {
|
||||
if (tegra_bpmp_is_response_ready(channel)) {
|
||||
tegra_bpmp_channel_signal(channel);
|
||||
clear_bit(i, busy);
|
||||
}
|
||||
|
|
@ -657,74 +692,9 @@ static void tegra_bpmp_handle_rx(struct mbox_client *client, void *data)
|
|||
spin_unlock(&bpmp->lock);
|
||||
}
|
||||
|
||||
static void tegra_bpmp_ivc_notify(struct tegra_ivc *ivc, void *data)
|
||||
{
|
||||
struct tegra_bpmp *bpmp = data;
|
||||
int err;
|
||||
|
||||
if (WARN_ON(bpmp->mbox.channel == NULL))
|
||||
return;
|
||||
|
||||
err = mbox_send_message(bpmp->mbox.channel, NULL);
|
||||
if (err < 0)
|
||||
return;
|
||||
|
||||
mbox_client_txdone(bpmp->mbox.channel, 0);
|
||||
}
|
||||
|
||||
static int tegra_bpmp_channel_init(struct tegra_bpmp_channel *channel,
|
||||
struct tegra_bpmp *bpmp,
|
||||
unsigned int index)
|
||||
{
|
||||
size_t message_size, queue_size;
|
||||
unsigned int offset;
|
||||
int err;
|
||||
|
||||
channel->ivc = devm_kzalloc(bpmp->dev, sizeof(*channel->ivc),
|
||||
GFP_KERNEL);
|
||||
if (!channel->ivc)
|
||||
return -ENOMEM;
|
||||
|
||||
message_size = tegra_ivc_align(MSG_MIN_SZ);
|
||||
queue_size = tegra_ivc_total_queue_size(message_size);
|
||||
offset = queue_size * index;
|
||||
|
||||
err = tegra_ivc_init(channel->ivc, NULL,
|
||||
bpmp->rx.virt + offset, bpmp->rx.phys + offset,
|
||||
bpmp->tx.virt + offset, bpmp->tx.phys + offset,
|
||||
1, message_size, tegra_bpmp_ivc_notify,
|
||||
bpmp);
|
||||
if (err < 0) {
|
||||
dev_err(bpmp->dev, "failed to setup IVC for channel %u: %d\n",
|
||||
index, err);
|
||||
return err;
|
||||
}
|
||||
|
||||
init_completion(&channel->completion);
|
||||
channel->bpmp = bpmp;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void tegra_bpmp_channel_reset(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
/* reset the channel state */
|
||||
tegra_ivc_reset(channel->ivc);
|
||||
|
||||
/* sync the channel state with BPMP */
|
||||
while (tegra_ivc_notified(channel->ivc))
|
||||
;
|
||||
}
|
||||
|
||||
static void tegra_bpmp_channel_cleanup(struct tegra_bpmp_channel *channel)
|
||||
{
|
||||
tegra_ivc_cleanup(channel->ivc);
|
||||
}
|
||||
|
||||
static int tegra_bpmp_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct tegra_bpmp *bpmp;
|
||||
unsigned int i;
|
||||
char tag[TAG_SZ];
|
||||
size_t size;
|
||||
int err;
|
||||
|
|
@ -736,32 +706,6 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
|
|||
bpmp->soc = of_device_get_match_data(&pdev->dev);
|
||||
bpmp->dev = &pdev->dev;
|
||||
|
||||
bpmp->tx.pool = of_gen_pool_get(pdev->dev.of_node, "shmem", 0);
|
||||
if (!bpmp->tx.pool) {
|
||||
dev_err(&pdev->dev, "TX shmem pool not found\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
bpmp->tx.virt = gen_pool_dma_alloc(bpmp->tx.pool, 4096, &bpmp->tx.phys);
|
||||
if (!bpmp->tx.virt) {
|
||||
dev_err(&pdev->dev, "failed to allocate from TX pool\n");
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
bpmp->rx.pool = of_gen_pool_get(pdev->dev.of_node, "shmem", 1);
|
||||
if (!bpmp->rx.pool) {
|
||||
dev_err(&pdev->dev, "RX shmem pool not found\n");
|
||||
err = -ENOMEM;
|
||||
goto free_tx;
|
||||
}
|
||||
|
||||
bpmp->rx.virt = gen_pool_dma_alloc(bpmp->rx.pool, 4096, &bpmp->rx.phys);
|
||||
if (!bpmp->rx.virt) {
|
||||
dev_err(&pdev->dev, "failed to allocate from RX pool\n");
|
||||
err = -ENOMEM;
|
||||
goto free_tx;
|
||||
}
|
||||
|
||||
INIT_LIST_HEAD(&bpmp->mrqs);
|
||||
spin_lock_init(&bpmp->lock);
|
||||
|
||||
|
|
@ -771,81 +715,38 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
|
|||
size = BITS_TO_LONGS(bpmp->threaded.count) * sizeof(long);
|
||||
|
||||
bpmp->threaded.allocated = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
|
||||
if (!bpmp->threaded.allocated) {
|
||||
err = -ENOMEM;
|
||||
goto free_rx;
|
||||
}
|
||||
if (!bpmp->threaded.allocated)
|
||||
return -ENOMEM;
|
||||
|
||||
bpmp->threaded.busy = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
|
||||
if (!bpmp->threaded.busy) {
|
||||
err = -ENOMEM;
|
||||
goto free_rx;
|
||||
}
|
||||
if (!bpmp->threaded.busy)
|
||||
return -ENOMEM;
|
||||
|
||||
spin_lock_init(&bpmp->atomic_tx_lock);
|
||||
bpmp->tx_channel = devm_kzalloc(&pdev->dev, sizeof(*bpmp->tx_channel),
|
||||
GFP_KERNEL);
|
||||
if (!bpmp->tx_channel) {
|
||||
err = -ENOMEM;
|
||||
goto free_rx;
|
||||
}
|
||||
if (!bpmp->tx_channel)
|
||||
return -ENOMEM;
|
||||
|
||||
bpmp->rx_channel = devm_kzalloc(&pdev->dev, sizeof(*bpmp->rx_channel),
|
||||
GFP_KERNEL);
|
||||
if (!bpmp->rx_channel) {
|
||||
err = -ENOMEM;
|
||||
goto free_rx;
|
||||
}
|
||||
if (!bpmp->rx_channel)
|
||||
return -ENOMEM;
|
||||
|
||||
bpmp->threaded_channels = devm_kcalloc(&pdev->dev, bpmp->threaded.count,
|
||||
sizeof(*bpmp->threaded_channels),
|
||||
GFP_KERNEL);
|
||||
if (!bpmp->threaded_channels) {
|
||||
err = -ENOMEM;
|
||||
goto free_rx;
|
||||
}
|
||||
if (!bpmp->threaded_channels)
|
||||
return -ENOMEM;
|
||||
|
||||
err = tegra_bpmp_channel_init(bpmp->tx_channel, bpmp,
|
||||
bpmp->soc->channels.cpu_tx.offset);
|
||||
err = bpmp->soc->ops->init(bpmp);
|
||||
if (err < 0)
|
||||
goto free_rx;
|
||||
|
||||
err = tegra_bpmp_channel_init(bpmp->rx_channel, bpmp,
|
||||
bpmp->soc->channels.cpu_rx.offset);
|
||||
if (err < 0)
|
||||
goto cleanup_tx_channel;
|
||||
|
||||
for (i = 0; i < bpmp->threaded.count; i++) {
|
||||
err = tegra_bpmp_channel_init(
|
||||
&bpmp->threaded_channels[i], bpmp,
|
||||
bpmp->soc->channels.thread.offset + i);
|
||||
if (err < 0)
|
||||
goto cleanup_threaded_channels;
|
||||
}
|
||||
|
||||
/* mbox registration */
|
||||
bpmp->mbox.client.dev = &pdev->dev;
|
||||
bpmp->mbox.client.rx_callback = tegra_bpmp_handle_rx;
|
||||
bpmp->mbox.client.tx_block = false;
|
||||
bpmp->mbox.client.knows_txdone = false;
|
||||
|
||||
bpmp->mbox.channel = mbox_request_channel(&bpmp->mbox.client, 0);
|
||||
if (IS_ERR(bpmp->mbox.channel)) {
|
||||
err = PTR_ERR(bpmp->mbox.channel);
|
||||
dev_err(&pdev->dev, "failed to get HSP mailbox: %d\n", err);
|
||||
goto cleanup_threaded_channels;
|
||||
}
|
||||
|
||||
/* reset message channels */
|
||||
tegra_bpmp_channel_reset(bpmp->tx_channel);
|
||||
tegra_bpmp_channel_reset(bpmp->rx_channel);
|
||||
for (i = 0; i < bpmp->threaded.count; i++)
|
||||
tegra_bpmp_channel_reset(&bpmp->threaded_channels[i]);
|
||||
return err;
|
||||
|
||||
err = tegra_bpmp_request_mrq(bpmp, MRQ_PING,
|
||||
tegra_bpmp_mrq_handle_ping, bpmp);
|
||||
if (err < 0)
|
||||
goto free_mbox;
|
||||
goto deinit;
|
||||
|
||||
err = tegra_bpmp_ping(bpmp);
|
||||
if (err < 0) {
|
||||
|
|
@ -867,17 +768,23 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
|
|||
if (err < 0)
|
||||
goto free_mrq;
|
||||
|
||||
err = tegra_bpmp_init_clocks(bpmp);
|
||||
if (err < 0)
|
||||
goto free_mrq;
|
||||
if (of_find_property(pdev->dev.of_node, "#clock-cells", NULL)) {
|
||||
err = tegra_bpmp_init_clocks(bpmp);
|
||||
if (err < 0)
|
||||
goto free_mrq;
|
||||
}
|
||||
|
||||
err = tegra_bpmp_init_resets(bpmp);
|
||||
if (err < 0)
|
||||
goto free_mrq;
|
||||
if (of_find_property(pdev->dev.of_node, "#reset-cells", NULL)) {
|
||||
err = tegra_bpmp_init_resets(bpmp);
|
||||
if (err < 0)
|
||||
goto free_mrq;
|
||||
}
|
||||
|
||||
err = tegra_bpmp_init_powergates(bpmp);
|
||||
if (err < 0)
|
||||
goto free_mrq;
|
||||
if (of_find_property(pdev->dev.of_node, "#power-domain-cells", NULL)) {
|
||||
err = tegra_bpmp_init_powergates(bpmp);
|
||||
if (err < 0)
|
||||
goto free_mrq;
|
||||
}
|
||||
|
||||
err = tegra_bpmp_init_debugfs(bpmp);
|
||||
if (err < 0)
|
||||
|
|
@ -887,41 +794,27 @@ static int tegra_bpmp_probe(struct platform_device *pdev)
|
|||
|
||||
free_mrq:
|
||||
tegra_bpmp_free_mrq(bpmp, MRQ_PING, bpmp);
|
||||
free_mbox:
|
||||
mbox_free_channel(bpmp->mbox.channel);
|
||||
cleanup_threaded_channels:
|
||||
for (i = 0; i < bpmp->threaded.count; i++) {
|
||||
if (bpmp->threaded_channels[i].bpmp)
|
||||
tegra_bpmp_channel_cleanup(&bpmp->threaded_channels[i]);
|
||||
}
|
||||
deinit:
|
||||
if (bpmp->soc->ops->deinit)
|
||||
bpmp->soc->ops->deinit(bpmp);
|
||||
|
||||
tegra_bpmp_channel_cleanup(bpmp->rx_channel);
|
||||
cleanup_tx_channel:
|
||||
tegra_bpmp_channel_cleanup(bpmp->tx_channel);
|
||||
free_rx:
|
||||
gen_pool_free(bpmp->rx.pool, (unsigned long)bpmp->rx.virt, 4096);
|
||||
free_tx:
|
||||
gen_pool_free(bpmp->tx.pool, (unsigned long)bpmp->tx.virt, 4096);
|
||||
return err;
|
||||
}
|
||||
|
||||
static int __maybe_unused tegra_bpmp_resume(struct device *dev)
|
||||
{
|
||||
struct tegra_bpmp *bpmp = dev_get_drvdata(dev);
|
||||
unsigned int i;
|
||||
|
||||
/* reset message channels */
|
||||
tegra_bpmp_channel_reset(bpmp->tx_channel);
|
||||
tegra_bpmp_channel_reset(bpmp->rx_channel);
|
||||
|
||||
for (i = 0; i < bpmp->threaded.count; i++)
|
||||
tegra_bpmp_channel_reset(&bpmp->threaded_channels[i]);
|
||||
|
||||
return 0;
|
||||
if (bpmp->soc->ops->resume)
|
||||
return bpmp->soc->ops->resume(bpmp);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
static SIMPLE_DEV_PM_OPS(tegra_bpmp_pm_ops, NULL, tegra_bpmp_resume);
|
||||
|
||||
#if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \
|
||||
IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC)
|
||||
static const struct tegra_bpmp_soc tegra186_soc = {
|
||||
.channels = {
|
||||
.cpu_tx = {
|
||||
|
|
@ -938,11 +831,42 @@ static const struct tegra_bpmp_soc tegra186_soc = {
|
|||
.timeout = 0,
|
||||
},
|
||||
},
|
||||
.ops = &tegra186_bpmp_ops,
|
||||
.num_resets = 193,
|
||||
};
|
||||
#endif
|
||||
|
||||
#if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC)
|
||||
static const struct tegra_bpmp_soc tegra210_soc = {
|
||||
.channels = {
|
||||
.cpu_tx = {
|
||||
.offset = 0,
|
||||
.count = 1,
|
||||
.timeout = 60 * USEC_PER_SEC,
|
||||
},
|
||||
.thread = {
|
||||
.offset = 4,
|
||||
.count = 1,
|
||||
.timeout = 600 * USEC_PER_SEC,
|
||||
},
|
||||
.cpu_rx = {
|
||||
.offset = 8,
|
||||
.count = 1,
|
||||
.timeout = 0,
|
||||
},
|
||||
},
|
||||
.ops = &tegra210_bpmp_ops,
|
||||
};
|
||||
#endif
|
||||
|
||||
static const struct of_device_id tegra_bpmp_match[] = {
|
||||
#if IS_ENABLED(CONFIG_ARCH_TEGRA_186_SOC) || \
|
||||
IS_ENABLED(CONFIG_ARCH_TEGRA_194_SOC)
|
||||
{ .compatible = "nvidia,tegra186-bpmp", .data = &tegra186_soc },
|
||||
#endif
|
||||
#if IS_ENABLED(CONFIG_ARCH_TEGRA_210_SOC)
|
||||
{ .compatible = "nvidia,tegra210-bpmp", .data = &tegra210_soc },
|
||||
#endif
|
||||
{ }
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -23,6 +23,7 @@
|
|||
#include <soc/tegra/bpmp-abi.h>
|
||||
|
||||
struct tegra_bpmp_clk;
|
||||
struct tegra_bpmp_ops;
|
||||
|
||||
struct tegra_bpmp_soc {
|
||||
struct {
|
||||
|
|
@ -32,6 +33,8 @@ struct tegra_bpmp_soc {
|
|||
unsigned int timeout;
|
||||
} cpu_tx, thread, cpu_rx;
|
||||
} channels;
|
||||
|
||||
const struct tegra_bpmp_ops *ops;
|
||||
unsigned int num_resets;
|
||||
};
|
||||
|
||||
|
|
@ -47,6 +50,7 @@ struct tegra_bpmp_channel {
|
|||
struct tegra_bpmp_mb_data *ob;
|
||||
struct completion completion;
|
||||
struct tegra_ivc *ivc;
|
||||
unsigned int index;
|
||||
};
|
||||
|
||||
typedef void (*tegra_bpmp_mrq_handler_t)(unsigned int mrq,
|
||||
|
|
@ -63,12 +67,7 @@ struct tegra_bpmp_mrq {
|
|||
struct tegra_bpmp {
|
||||
const struct tegra_bpmp_soc *soc;
|
||||
struct device *dev;
|
||||
|
||||
struct {
|
||||
struct gen_pool *pool;
|
||||
dma_addr_t phys;
|
||||
void *virt;
|
||||
} tx, rx;
|
||||
void *priv;
|
||||
|
||||
struct {
|
||||
struct mbox_client client;
|
||||
|
|
@ -173,6 +172,8 @@ static inline bool tegra_bpmp_mrq_is_supported(struct tegra_bpmp *bpmp,
|
|||
}
|
||||
#endif
|
||||
|
||||
void tegra_bpmp_handle_rx(struct tegra_bpmp *bpmp);
|
||||
|
||||
#if IS_ENABLED(CONFIG_CLK_TEGRA_BPMP)
|
||||
int tegra_bpmp_init_clocks(struct tegra_bpmp *bpmp);
|
||||
#else
|
||||
|
|
|
|||
Loading…
Reference in New Issue