drivers/misc/tegra186_bpmp.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2016, NVIDIA CORPORATION.
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <time.h>
   9 #include <dm/lists.h>
  10 #include <dm/root.h>
  11 #include <mailbox.h>
  12 #include <misc.h>
  13 #include <asm/arch-tegra/bpmp_abi.h>
  14 #include <asm/arch-tegra/ivc.h>
  15 #include <linux/err.h>
  16
  17 #define BPMP_IVC_FRAME_COUNT 1
  18 #define BPMP_IVC_FRAME_SIZE 128
  19
  20 #define BPMP_FLAG_DO_ACK        BIT(0)
  21 #define BPMP_FLAG_RING_DOORBELL BIT(1)
  22
  23 DECLARE_GLOBAL_DATA_PTR;
  24
  25 struct tegra186_bpmp {
  26         struct mbox_chan mbox;
  27         struct tegra_ivc ivc;
  28 };
  29
  30 static int tegra186_bpmp_call(struct udevice *dev, int mrq, void *tx_msg,
  31                               int tx_size, void *rx_msg, int rx_size)
  32 {
  33         struct tegra186_bpmp *priv = dev_get_priv(dev);
  34         int ret, err;
  35         void *ivc_frame;
  36         struct mrq_request *req;
  37         struct mrq_response *resp;
  38         ulong start_time;
  39
  40         debug("%s(dev=%p, mrq=%u, tx_msg=%p, tx_size=%d, rx_msg=%p, rx_size=%d) (priv=%p)\n",
  41               __func__, dev, mrq, tx_msg, tx_size, rx_msg, rx_size, priv);
  42
  43         if ((tx_size > BPMP_IVC_FRAME_SIZE) || (rx_size > BPMP_IVC_FRAME_SIZE))
  44                 return -EINVAL;
  45
  46         ret = tegra_ivc_write_get_next_frame(&priv->ivc, &ivc_frame);
  47         if (ret) {
  48                 pr_err("tegra_ivc_write_get_next_frame() failed: %d\n", ret);
  49                 return ret;
  50         }
  51
  52         req = ivc_frame;
  53         req->mrq = mrq;
  54         req->flags = BPMP_FLAG_DO_ACK | BPMP_FLAG_RING_DOORBELL;
  55         memcpy(req + 1, tx_msg, tx_size);
  56
  57         ret = tegra_ivc_write_advance(&priv->ivc);
  58         if (ret) {
  59                 pr_err("tegra_ivc_write_advance() failed: %d\n", ret);
  60                 return ret;
  61         }
  62
  63         start_time = timer_get_us();
  64         for (;;) {
  65                 ret = tegra_ivc_channel_notified(&priv->ivc);
  66                 if (ret) {
  67                         pr_err("tegra_ivc_channel_notified() failed: %d\n", ret);
  68                         return ret;
  69                 }
  70
  71                 ret = tegra_ivc_read_get_next_frame(&priv->ivc, &ivc_frame);
  72                 if (!ret)
  73                         break;
  74
  75                 /* Timeout 20ms; roughly 10x current max observed duration */
  76                 if ((timer_get_us() - start_time) > 20 * 1000) {
  77                         pr_err("tegra_ivc_read_get_next_frame() timed out (%d)\n",
  78                               ret);
  79                         return -ETIMEDOUT;
  80                 }
  81         }
  82
  83         resp = ivc_frame;
  84         err = resp->err;
  85         if (!err && rx_msg && rx_size)
  86                 memcpy(rx_msg, resp + 1, rx_size);
  87
  88         ret = tegra_ivc_read_advance(&priv->ivc);
  89         if (ret) {
  90                 pr_err("tegra_ivc_write_advance() failed: %d\n", ret);
  91                 return ret;
  92         }
  93
  94         if (err) {
  95                 pr_err("BPMP responded with error %d\n", err);
  96                 /* err isn't a U-Boot error code, so don't that */
  97                 return -EIO;
  98         }
  99
 100         return rx_size;
 101 }
 102
 103 /**
 104  * The BPMP exposes multiple different services. We create a sub-device for
 105  * each separate type of service, since each device must be of the appropriate
 106  * UCLASS.
 107  */
 108 static int tegra186_bpmp_bind(struct udevice *dev)
 109 {
 110         int ret;
 111         struct udevice *child;
 112
 113         debug("%s(dev=%p)\n", __func__, dev);
 114
 115         ret = device_bind_driver_to_node(dev, "tegra186_clk", "tegra186_clk",
 116                                          dev_ofnode(dev), &child);
 117         if (ret)
 118                 return ret;
 119
 120         ret = device_bind_driver_to_node(dev, "tegra186_reset",
 121                                          "tegra186_reset", dev_ofnode(dev),
 122                                          &child);
 123         if (ret)
 124                 return ret;
 125
 126         ret = device_bind_driver_to_node(dev, "tegra186_power_domain",
 127                                          "tegra186_power_domain",
 128                                          dev_ofnode(dev), &child);
 129         if (ret)
 130                 return ret;
 131
 132         ret = dm_scan_fdt_dev(dev);
 133         if (ret)
 134                 return ret;
 135
 136         return 0;
 137 }
 138
 139 static ulong tegra186_bpmp_get_shmem(struct udevice *dev, int index)
 140 {
 141         int ret;
 142         struct fdtdec_phandle_args args;
 143         fdt_addr_t reg;
 144
 145         ret = fdtdec_parse_phandle_with_args(gd->fdt_blob, dev_of_offset(dev),
 146                                               "shmem", NULL, 0, index, &args);
 147         if (ret < 0) {
 148                 pr_err("fdtdec_parse_phandle_with_args() failed: %d\n", ret);
 149                 return ret;
 150         }
 151
 152         reg = fdtdec_get_addr_size_auto_noparent(gd->fdt_blob, args.node,
 153                                                  "reg", 0, NULL, true);
 154         if (reg == FDT_ADDR_T_NONE) {
 155                 pr_err("fdtdec_get_addr_size_auto_noparent() failed\n");
 156                 return -ENODEV;
 157         }
 158
 159         return reg;
 160 }
 161
 162 static void tegra186_bpmp_ivc_notify(struct tegra_ivc *ivc)
 163 {
 164         struct tegra186_bpmp *priv =
 165                 container_of(ivc, struct tegra186_bpmp, ivc);
 166         int ret;
 167
 168         ret = mbox_send(&priv->mbox, NULL);
 169         if (ret)
 170                 pr_err("mbox_send() failed: %d\n", ret);
 171 }
 172
 173 static int tegra186_bpmp_probe(struct udevice *dev)
 174 {
 175         struct tegra186_bpmp *priv = dev_get_priv(dev);
 176         int ret;
 177         ulong tx_base, rx_base, start_time;
 178
 179         debug("%s(dev=%p) (priv=%p)\n", __func__, dev, priv);
 180
 181         ret = mbox_get_by_index(dev, 0, &priv->mbox);
 182         if (ret) {
 183                 pr_err("mbox_get_by_index() failed: %d\n", ret);
 184                 return ret;
 185         }
 186
 187         tx_base = tegra186_bpmp_get_shmem(dev, 0);
 188         if (IS_ERR_VALUE(tx_base)) {
 189                 pr_err("tegra186_bpmp_get_shmem failed for tx_base\n");
 190                 return tx_base;
 191         }
 192         rx_base = tegra186_bpmp_get_shmem(dev, 1);
 193         if (IS_ERR_VALUE(rx_base)) {
 194                 pr_err("tegra186_bpmp_get_shmem failed for rx_base\n");
 195                 return rx_base;
 196         }
 197         debug("shmem: rx=%lx, tx=%lx\n", rx_base, tx_base);
 198
 199         ret = tegra_ivc_init(&priv->ivc, rx_base, tx_base, BPMP_IVC_FRAME_COUNT,
 200                              BPMP_IVC_FRAME_SIZE, tegra186_bpmp_ivc_notify);
 201         if (ret) {
 202                 pr_err("tegra_ivc_init() failed: %d\n", ret);
 203                 return ret;
 204         }
 205
 206         tegra_ivc_channel_reset(&priv->ivc);
 207         start_time = timer_get_us();
 208         for (;;) {
 209                 ret = tegra_ivc_channel_notified(&priv->ivc);
 210                 if (!ret)
 211                         break;
 212
 213                 /* Timeout 100ms */
 214                 if ((timer_get_us() - start_time) > 100 * 1000) {
 215                         pr_err("Initial IVC reset timed out (%d)\n", ret);
 216                         ret = -ETIMEDOUT;
 217                         goto err_free_mbox;
 218                 }
 219         }
 220
 221         return 0;
 222
 223 err_free_mbox:
 224         mbox_free(&priv->mbox);
 225
 226         return ret;
 227 }
 228
 229 static int tegra186_bpmp_remove(struct udevice *dev)
 230 {
 231         struct tegra186_bpmp *priv = dev_get_priv(dev);
 232
 233         debug("%s(dev=%p) (priv=%p)\n", __func__, dev, priv);
 234
 235         mbox_free(&priv->mbox);
 236
 237         return 0;
 238 }
 239
 240 static struct misc_ops tegra186_bpmp_ops = {
 241         .call = tegra186_bpmp_call,
 242 };
 243
 244 static const struct udevice_id tegra186_bpmp_ids[] = {
 245         { .compatible = "nvidia,tegra186-bpmp" },
 246         { }
 247 };
 248
 249 U_BOOT_DRIVER(tegra186_bpmp) = {
 250         .name           = "tegra186_bpmp",
 251         .id             = UCLASS_MISC,
 252         .of_match       = tegra186_bpmp_ids,
 253         .bind           = tegra186_bpmp_bind,
 254         .probe          = tegra186_bpmp_probe,
 255         .remove         = tegra186_bpmp_remove,
 256         .ops            = &tegra186_bpmp_ops,
 257         .priv_auto_alloc_size = sizeof(struct tegra186_bpmp),
 258 };