drivers/firmware/tegra/bpmp-tegra186.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2018, NVIDIA CORPORATION.
   4  */
   5
   6 #include <linux/genalloc.h>
   7 #include <linux/mailbox_client.h>
   8 #include <linux/platform_device.h>
   9
  10 #include <soc/tegra/bpmp.h>
  11 #include <soc/tegra/bpmp-abi.h>
  12 #include <soc/tegra/ivc.h>
  13
  14 #include "bpmp-private.h"
  15
  16 struct tegra186_bpmp {
  17         struct tegra_bpmp *parent;
  18
  19         struct {
  20                 struct gen_pool *pool;
  21                 dma_addr_t phys;
  22                 void *virt;
  23         } tx, rx;
  24
  25         struct {
  26                 struct mbox_client client;
  27                 struct mbox_chan *channel;
  28         } mbox;
  29 };
  30
  31 static inline struct tegra_bpmp *
  32 mbox_client_to_bpmp(struct mbox_client *client)
  33 {
  34         struct tegra186_bpmp *priv;
  35
  36         priv = container_of(client, struct tegra186_bpmp, mbox.client);
  37
  38         return priv->parent;
  39 }
  40
  41 static bool tegra186_bpmp_is_message_ready(struct tegra_bpmp_channel *channel)
  42 {
  43         void *frame;
  44
  45         frame = tegra_ivc_read_get_next_frame(channel->ivc);
  46         if (IS_ERR(frame)) {
  47                 channel->ib = NULL;
  48                 return false;
  49         }
  50
  51         channel->ib = frame;
  52
  53         return true;
  54 }
  55
  56 static bool tegra186_bpmp_is_channel_free(struct tegra_bpmp_channel *channel)
  57 {
  58         void *frame;
  59
  60         frame = tegra_ivc_write_get_next_frame(channel->ivc);
  61         if (IS_ERR(frame)) {
  62                 channel->ob = NULL;
  63                 return false;
  64         }
  65
  66         channel->ob = frame;
  67
  68         return true;
  69 }
  70
  71 static int tegra186_bpmp_ack_message(struct tegra_bpmp_channel *channel)
  72 {
  73         return tegra_ivc_read_advance(channel->ivc);
  74 }
  75
  76 static int tegra186_bpmp_post_message(struct tegra_bpmp_channel *channel)
  77 {
  78         return tegra_ivc_write_advance(channel->ivc);
  79 }
  80
  81 static int tegra186_bpmp_ring_doorbell(struct tegra_bpmp *bpmp)
  82 {
  83         struct tegra186_bpmp *priv = bpmp->priv;
  84         int err;
  85
  86         err = mbox_send_message(priv->mbox.channel, NULL);
  87         if (err < 0)
  88                 return err;
  89
  90         mbox_client_txdone(priv->mbox.channel, 0);
  91
  92         return 0;
  93 }
  94
  95 static void tegra186_bpmp_ivc_notify(struct tegra_ivc *ivc, void *data)
  96 {
  97         struct tegra_bpmp *bpmp = data;
  98         struct tegra186_bpmp *priv = bpmp->priv;
  99
 100         if (WARN_ON(priv->mbox.channel == NULL))
 101                 return;
 102
 103         tegra186_bpmp_ring_doorbell(bpmp);
 104 }
 105
 106 static int tegra186_bpmp_channel_init(struct tegra_bpmp_channel *channel,
 107                                       struct tegra_bpmp *bpmp,
 108                                       unsigned int index)
 109 {
 110         struct tegra186_bpmp *priv = bpmp->priv;
 111         size_t message_size, queue_size;
 112         unsigned int offset;
 113         int err;
 114
 115         channel->ivc = devm_kzalloc(bpmp->dev, sizeof(*channel->ivc),
 116                                     GFP_KERNEL);
 117         if (!channel->ivc)
 118                 return -ENOMEM;
 119
 120         message_size = tegra_ivc_align(MSG_MIN_SZ);
 121         queue_size = tegra_ivc_total_queue_size(message_size);
 122         offset = queue_size * index;
 123
 124         err = tegra_ivc_init(channel->ivc, NULL,
 125                              priv->rx.virt + offset, priv->rx.phys + offset,
 126                              priv->tx.virt + offset, priv->tx.phys + offset,
 127                              1, message_size, tegra186_bpmp_ivc_notify,
 128                              bpmp);
 129         if (err < 0) {
 130                 dev_err(bpmp->dev, "failed to setup IVC for channel %u: %d\n",
 131                         index, err);
 132                 return err;
 133         }
 134
 135         init_completion(&channel->completion);
 136         channel->bpmp = bpmp;
 137
 138         return 0;
 139 }
 140
 141 static void tegra186_bpmp_channel_reset(struct tegra_bpmp_channel *channel)
 142 {
 143         /* reset the channel state */
 144         tegra_ivc_reset(channel->ivc);
 145
 146         /* sync the channel state with BPMP */
 147         while (tegra_ivc_notified(channel->ivc))
 148                 ;
 149 }
 150
 151 static void tegra186_bpmp_channel_cleanup(struct tegra_bpmp_channel *channel)
 152 {
 153         tegra_ivc_cleanup(channel->ivc);
 154 }
 155
 156 static void mbox_handle_rx(struct mbox_client *client, void *data)
 157 {
 158         struct tegra_bpmp *bpmp = mbox_client_to_bpmp(client);
 159
 160         tegra_bpmp_handle_rx(bpmp);
 161 }
 162
 163 static int tegra186_bpmp_init(struct tegra_bpmp *bpmp)
 164 {
 165         struct tegra186_bpmp *priv;
 166         unsigned int i;
 167         int err;
 168
 169         priv = devm_kzalloc(bpmp->dev, sizeof(*priv), GFP_KERNEL);
 170         if (!priv)
 171                 return -ENOMEM;
 172
 173         bpmp->priv = priv;
 174         priv->parent = bpmp;
 175
 176         priv->tx.pool = of_gen_pool_get(bpmp->dev->of_node, "shmem", 0);
 177         if (!priv->tx.pool) {
 178                 dev_err(bpmp->dev, "TX shmem pool not found\n");
 179                 return -ENOMEM;
 180         }
 181
 182         priv->tx.virt = gen_pool_dma_alloc(priv->tx.pool, 4096, &priv->tx.phys);
 183         if (!priv->tx.virt) {
 184                 dev_err(bpmp->dev, "failed to allocate from TX pool\n");
 185                 return -ENOMEM;
 186         }
 187
 188         priv->rx.pool = of_gen_pool_get(bpmp->dev->of_node, "shmem", 1);
 189         if (!priv->rx.pool) {
 190                 dev_err(bpmp->dev, "RX shmem pool not found\n");
 191                 err = -ENOMEM;
 192                 goto free_tx;
 193         }
 194
 195         priv->rx.virt = gen_pool_dma_alloc(priv->rx.pool, 4096, &priv->rx.phys);
 196         if (!priv->rx.virt) {
 197                 dev_err(bpmp->dev, "failed to allocate from RX pool\n");
 198                 err = -ENOMEM;
 199                 goto free_tx;
 200         }
 201
 202         err = tegra186_bpmp_channel_init(bpmp->tx_channel, bpmp,
 203                                          bpmp->soc->channels.cpu_tx.offset);
 204         if (err < 0)
 205                 goto free_rx;
 206
 207         err = tegra186_bpmp_channel_init(bpmp->rx_channel, bpmp,
 208                                          bpmp->soc->channels.cpu_rx.offset);
 209         if (err < 0)
 210                 goto cleanup_tx_channel;
 211
 212         for (i = 0; i < bpmp->threaded.count; i++) {
 213                 unsigned int index = bpmp->soc->channels.thread.offset + i;
 214
 215                 err = tegra186_bpmp_channel_init(&bpmp->threaded_channels[i],
 216                                                  bpmp, index);
 217                 if (err < 0)
 218                         goto cleanup_channels;
 219         }
 220
 221         /* mbox registration */
 222         priv->mbox.client.dev = bpmp->dev;
 223         priv->mbox.client.rx_callback = mbox_handle_rx;
 224         priv->mbox.client.tx_block = false;
 225         priv->mbox.client.knows_txdone = false;
 226
 227         priv->mbox.channel = mbox_request_channel(&priv->mbox.client, 0);
 228         if (IS_ERR(priv->mbox.channel)) {
 229                 err = PTR_ERR(priv->mbox.channel);
 230                 dev_err(bpmp->dev, "failed to get HSP mailbox: %d\n", err);
 231                 goto cleanup_channels;
 232         }
 233
 234         tegra186_bpmp_channel_reset(bpmp->tx_channel);
 235         tegra186_bpmp_channel_reset(bpmp->rx_channel);
 236
 237         for (i = 0; i < bpmp->threaded.count; i++)
 238                 tegra186_bpmp_channel_reset(&bpmp->threaded_channels[i]);
 239
 240         return 0;
 241
 242 cleanup_channels:
 243         for (i = 0; i < bpmp->threaded.count; i++) {
 244                 if (!bpmp->threaded_channels[i].bpmp)
 245                         continue;
 246
 247                 tegra186_bpmp_channel_cleanup(&bpmp->threaded_channels[i]);
 248         }
 249
 250         tegra186_bpmp_channel_cleanup(bpmp->rx_channel);
 251 cleanup_tx_channel:
 252         tegra186_bpmp_channel_cleanup(bpmp->tx_channel);
 253 free_rx:
 254         gen_pool_free(priv->rx.pool, (unsigned long)priv->rx.virt, 4096);
 255 free_tx:
 256         gen_pool_free(priv->tx.pool, (unsigned long)priv->tx.virt, 4096);
 257
 258         return err;
 259 }
 260
 261 static void tegra186_bpmp_deinit(struct tegra_bpmp *bpmp)
 262 {
 263         struct tegra186_bpmp *priv = bpmp->priv;
 264         unsigned int i;
 265
 266         mbox_free_channel(priv->mbox.channel);
 267
 268         for (i = 0; i < bpmp->threaded.count; i++)
 269                 tegra186_bpmp_channel_cleanup(&bpmp->threaded_channels[i]);
 270
 271         tegra186_bpmp_channel_cleanup(bpmp->rx_channel);
 272         tegra186_bpmp_channel_cleanup(bpmp->tx_channel);
 273
 274         gen_pool_free(priv->rx.pool, (unsigned long)priv->rx.virt, 4096);
 275         gen_pool_free(priv->tx.pool, (unsigned long)priv->tx.virt, 4096);
 276 }
 277
 278 static int tegra186_bpmp_resume(struct tegra_bpmp *bpmp)
 279 {
 280         unsigned int i;
 281
 282         /* reset message channels */
 283         tegra186_bpmp_channel_reset(bpmp->tx_channel);
 284         tegra186_bpmp_channel_reset(bpmp->rx_channel);
 285
 286         for (i = 0; i < bpmp->threaded.count; i++)
 287                 tegra186_bpmp_channel_reset(&bpmp->threaded_channels[i]);
 288
 289         return 0;
 290 }
 291
 292 const struct tegra_bpmp_ops tegra186_bpmp_ops = {
 293         .init = tegra186_bpmp_init,
 294         .deinit = tegra186_bpmp_deinit,
 295         .is_response_ready = tegra186_bpmp_is_message_ready,
 296         .is_request_ready = tegra186_bpmp_is_message_ready,
 297         .ack_response = tegra186_bpmp_ack_message,
 298         .ack_request = tegra186_bpmp_ack_message,
 299         .is_response_channel_free = tegra186_bpmp_is_channel_free,
 300         .is_request_channel_free = tegra186_bpmp_is_channel_free,
 301         .post_response = tegra186_bpmp_post_message,
 302         .post_request = tegra186_bpmp_post_message,
 303         .ring_doorbell = tegra186_bpmp_ring_doorbell,
 304         .resume = tegra186_bpmp_resume,
 305 };