Quelle  bpmp-tegra186.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2018, NVIDIA CORPORATION.
 */

#include <linux/genalloc.h>
#include <linux/io.h>
#include <linux/mailbox_client.h>
#include <linux/of_reserved_mem.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;
  union {
   void __iomem *sram;
   void *dram;
  };
  dma_addr_t phys;
 } 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)
{
 int err;

 err = tegra_ivc_read_get_next_frame(channel->ivc, &channel->ib);
 if (err) {
  iosys_map_clear(&channel->ib);
  return false;
 }

 return true;
}

static bool tegra186_bpmp_is_channel_free(struct tegra_bpmp_channel *channel)
{
 int err;

 err = tegra_ivc_write_get_next_frame(channel->ivc, &channel->ob);
 if (err) {
  iosys_map_clear(&channel->ob);
  return false;
 }

 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;
 struct iosys_map rx, tx;
 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;

 if (priv->rx.pool) {
  iosys_map_set_vaddr_iomem(&rx, priv->rx.sram + offset);
  iosys_map_set_vaddr_iomem(&tx, priv->tx.sram + offset);
 } else {
  iosys_map_set_vaddr(&rx, priv->rx.dram + offset);
  iosys_map_set_vaddr(&tx, priv->tx.dram + offset);
 }

 err = tegra_ivc_init(channel->ivc, NULL, &rx, priv->rx.phys + offset, &tx,
        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 void tegra186_bpmp_teardown_channels(struct tegra_bpmp *bpmp)
{
 struct tegra186_bpmp *priv = bpmp->priv;
 unsigned int i;

 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);
 tegra186_bpmp_channel_cleanup(bpmp->tx_channel);

 if (priv->tx.pool) {
  gen_pool_free(priv->tx.pool, (unsigned long)priv->tx.sram, 4096);
  gen_pool_free(priv->rx.pool, (unsigned long)priv->rx.sram, 4096);
 }
}

static int tegra186_bpmp_dram_init(struct tegra_bpmp *bpmp)
{
 struct tegra186_bpmp *priv = bpmp->priv;
 struct resource res;
 size_t size;
 int err;

 err = of_reserved_mem_region_to_resource(bpmp->dev->of_node, 0, &res);
 if (err < 0) {
  if (err != -ENODEV)
   dev_warn(bpmp->dev,
     "failed to parse memory region: %d\n", err);

  return err;
 }

 size = resource_size(&res);

 if (size < SZ_8K) {
  dev_warn(bpmp->dev, "DRAM region must be larger than 8 KiB\n");
  return -EINVAL;
 }

 priv->tx.phys = res.start;
 priv->rx.phys = res.start + SZ_4K;

 priv->tx.dram = devm_memremap(bpmp->dev, priv->tx.phys, size,
          MEMREMAP_WC);
 if (IS_ERR(priv->tx.dram)) {
  err = PTR_ERR(priv->tx.dram);
  dev_warn(bpmp->dev, "failed to map DRAM region: %d\n", err);
  return err;
 }

 priv->rx.dram = priv->tx.dram + SZ_4K;

 return 0;
}

static int tegra186_bpmp_sram_init(struct tegra_bpmp *bpmp)
{
 struct tegra186_bpmp *priv = bpmp->priv;
 int err;

 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 -EPROBE_DEFER;
 }

 priv->tx.sram = (void __iomem *)gen_pool_dma_alloc(priv->tx.pool, 4096,
          &priv->tx.phys);
 if (!priv->tx.sram) {
  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 = -EPROBE_DEFER;
  goto free_tx;
 }

 priv->rx.sram = (void __iomem *)gen_pool_dma_alloc(priv->rx.pool, 4096,
          &priv->rx.phys);
 if (!priv->rx.sram) {
  dev_err(bpmp->dev, "failed to allocate from RX pool\n");
  err = -ENOMEM;
  goto free_tx;
 }

 return 0;

free_tx:
 gen_pool_free(priv->tx.pool, (unsigned long)priv->tx.sram, 4096);

 return err;
}

static int tegra186_bpmp_setup_channels(struct tegra_bpmp *bpmp)
{
 unsigned int i;
 int err;

 err = tegra186_bpmp_dram_init(bpmp);
 if (err == -ENODEV) {
  err = tegra186_bpmp_sram_init(bpmp);
  if (err < 0)
   return err;
 }

 err = tegra186_bpmp_channel_init(bpmp->tx_channel, bpmp,
      bpmp->soc->channels.cpu_tx.offset);
 if (err < 0)
  return err;

 err = tegra186_bpmp_channel_init(bpmp->rx_channel, bpmp,
      bpmp->soc->channels.cpu_rx.offset);
 if (err < 0) {
  tegra186_bpmp_channel_cleanup(bpmp->tx_channel);
  return err;
 }

 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)
   break;
 }

 if (err < 0)
  tegra186_bpmp_teardown_channels(bpmp);

 return err;
}

static void tegra186_bpmp_reset_channels(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]);
}

static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)
{
 struct tegra186_bpmp *priv;
 int err;

 priv = devm_kzalloc(bpmp->dev, sizeof(*priv), GFP_KERNEL);
 if (!priv)
  return -ENOMEM;

 priv->parent = bpmp;
 bpmp->priv = priv;

 err = tegra186_bpmp_setup_channels(bpmp);
 if (err < 0)
  return err;

 /* 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);
  tegra186_bpmp_teardown_channels(bpmp);
  return err;
 }

 tegra186_bpmp_reset_channels(bpmp);

 return 0;
}

static void tegra186_bpmp_deinit(struct tegra_bpmp *bpmp)
{
 struct tegra186_bpmp *priv = bpmp->priv;

 mbox_free_channel(priv->mbox.channel);

 tegra186_bpmp_teardown_channels(bpmp);
}

static int tegra186_bpmp_resume(struct tegra_bpmp *bpmp)
{
 tegra186_bpmp_reset_channels(bpmp);

 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,
};