drivers/media/platform/amphion/vpu_mbox.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright 2020-2021 NXP
   4  */
   5
   6 #include <linux/init.h>
   7 #include <linux/interconnect.h>
   8 #include <linux/ioctl.h>
   9 #include <linux/list.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/of_device.h>
  13 #include <linux/of_address.h>
  14 #include <linux/platform_device.h>
  15 #include "vpu.h"
  16 #include "vpu_mbox.h"
  17 #include "vpu_msgs.h"
  18
  19 static void vpu_mbox_rx_callback(struct mbox_client *cl, void *msg)
  20 {
  21         struct vpu_mbox *rx = container_of(cl, struct vpu_mbox, cl);
  22         struct vpu_core *core = container_of(rx, struct vpu_core, rx);
  23
  24         vpu_isr(core, *(u32 *)msg);
  25 }
  26
  27 static int vpu_mbox_request_channel(struct device *dev, struct vpu_mbox *mbox)
  28 {
  29         struct mbox_chan *ch;
  30         struct mbox_client *cl;
  31
  32         if (!dev || !mbox)
  33                 return -EINVAL;
  34         if (mbox->ch)
  35                 return 0;
  36
  37         cl = &mbox->cl;
  38         cl->dev = dev;
  39         if (mbox->block) {
  40                 cl->tx_block = true;
  41                 cl->tx_tout = 1000;
  42         } else {
  43                 cl->tx_block = false;
  44         }
  45         cl->knows_txdone = false;
  46         cl->rx_callback = vpu_mbox_rx_callback;
  47
  48         ch = mbox_request_channel_byname(cl, mbox->name);
  49         if (IS_ERR(ch)) {
  50                 dev_err(dev, "Failed to request mbox chan %s, ret : %ld\n",
  51                         mbox->name, PTR_ERR(ch));
  52                 return PTR_ERR(ch);
  53         }
  54
  55         mbox->ch = ch;
  56         return 0;
  57 }
  58
  59 int vpu_mbox_init(struct vpu_core *core)
  60 {
  61         scnprintf(core->tx_type.name, sizeof(core->tx_type.name) - 1, "tx0");
  62         core->tx_type.block = true;
  63
  64         scnprintf(core->tx_data.name, sizeof(core->tx_data.name) - 1, "tx1");
  65         core->tx_data.block = false;
  66
  67         scnprintf(core->rx.name, sizeof(core->rx.name) - 1, "rx");
  68         core->rx.block = true;
  69
  70         return 0;
  71 }
  72
  73 int vpu_mbox_request(struct vpu_core *core)
  74 {
  75         int ret;
  76
  77         ret = vpu_mbox_request_channel(core->dev, &core->tx_type);
  78         if (ret)
  79                 goto error;
  80         ret = vpu_mbox_request_channel(core->dev, &core->tx_data);
  81         if (ret)
  82                 goto error;
  83         ret = vpu_mbox_request_channel(core->dev, &core->rx);
  84         if (ret)
  85                 goto error;
  86
  87         dev_dbg(core->dev, "%s request mbox\n", vpu_core_type_desc(core->type));
  88         return 0;
  89 error:
  90         vpu_mbox_free(core);
  91         return ret;
  92 }
  93
  94 void vpu_mbox_free(struct vpu_core *core)
  95 {
  96         mbox_free_channel(core->tx_type.ch);
  97         mbox_free_channel(core->tx_data.ch);
  98         mbox_free_channel(core->rx.ch);
  99         core->tx_type.ch = NULL;
 100         core->tx_data.ch = NULL;
 101         core->rx.ch = NULL;
 102         dev_dbg(core->dev, "%s free mbox\n", vpu_core_type_desc(core->type));
 103 }
 104
 105 void vpu_mbox_send_type(struct vpu_core *core, u32 type)
 106 {
 107         mbox_send_message(core->tx_type.ch, &type);
 108 }
 109
 110 void vpu_mbox_send_msg(struct vpu_core *core, u32 type, u32 data)
 111 {
 112         mbox_send_message(core->tx_data.ch, &data);
 113         mbox_send_message(core->tx_type.ch, &type);
 114 }
 115
 116 void vpu_mbox_enable_rx(struct vpu_dev *dev)
 117 {
 118 }