drivers/interconnect/imx/imx.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Interconnect framework driver for i.MX SoC
   4  *
   5  * Copyright (c) 2019, BayLibre
   6  * Copyright (c) 2019-2020, NXP
   7  * Author: Alexandre Bailon <abailon@baylibre.com>
   8  * Author: Leonard Crestez <leonard.crestez@nxp.com>
   9  */
  10
  11 #include <linux/device.h>
  12 #include <linux/interconnect-provider.h>
  13 #include <linux/module.h>
  14 #include <linux/of.h>
  15 #include <linux/of_platform.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/pm_qos.h>
  18
  19 #include "imx.h"
  20
  21 /* private icc_node data */
  22 struct imx_icc_node {
  23         const struct imx_icc_node_desc *desc;
  24         struct device *qos_dev;
  25         struct dev_pm_qos_request qos_req;
  26 };
  27
  28 static int imx_icc_get_bw(struct icc_node *node, u32 *avg, u32 *peak)
  29 {
  30         *avg = 0;
  31         *peak = 0;
  32
  33         return 0;
  34 }
  35
  36 static int imx_icc_node_set(struct icc_node *node)
  37 {
  38         struct device *dev = node->provider->dev;
  39         struct imx_icc_node *node_data = node->data;
  40         u64 freq;
  41
  42         if (!node_data->qos_dev)
  43                 return 0;
  44
  45         freq = (node->avg_bw + node->peak_bw) * node_data->desc->adj->bw_mul;
  46         do_div(freq, node_data->desc->adj->bw_div);
  47         dev_dbg(dev, "node %s device %s avg_bw %ukBps peak_bw %ukBps min_freq %llukHz\n",
  48                 node->name, dev_name(node_data->qos_dev),
  49                 node->avg_bw, node->peak_bw, freq);
  50
  51         if (freq > S32_MAX) {
  52                 dev_err(dev, "%s can't request more than S32_MAX freq\n",
  53                                 node->name);
  54                 return -ERANGE;
  55         }
  56
  57         dev_pm_qos_update_request(&node_data->qos_req, freq);
  58
  59         return 0;
  60 }
  61
  62 static int imx_icc_set(struct icc_node *src, struct icc_node *dst)
  63 {
  64         return imx_icc_node_set(dst);
  65 }
  66
  67 /* imx_icc_node_destroy() - Destroy an imx icc_node, including private data */
  68 static void imx_icc_node_destroy(struct icc_node *node)
  69 {
  70         struct imx_icc_node *node_data = node->data;
  71         int ret;
  72
  73         if (dev_pm_qos_request_active(&node_data->qos_req)) {
  74                 ret = dev_pm_qos_remove_request(&node_data->qos_req);
  75                 if (ret)
  76                         dev_warn(node->provider->dev,
  77                                  "failed to remove qos request for %s\n",
  78                                  dev_name(node_data->qos_dev));
  79         }
  80
  81         put_device(node_data->qos_dev);
  82         icc_node_del(node);
  83         icc_node_destroy(node->id);
  84 }
  85
  86 static int imx_icc_node_init_qos(struct icc_provider *provider,
  87                                  struct icc_node *node)
  88 {
  89         struct imx_icc_node *node_data = node->data;
  90         const struct imx_icc_node_adj_desc *adj = node_data->desc->adj;
  91         struct device *dev = provider->dev;
  92         struct device_node *dn = NULL;
  93         struct platform_device *pdev;
  94
  95         if (adj->main_noc) {
  96                 node_data->qos_dev = dev;
  97                 dev_dbg(dev, "icc node %s[%d] is main noc itself\n",
  98                         node->name, node->id);
  99         } else {
 100                 dn = of_parse_phandle(dev->of_node, adj->phandle_name, 0);
 101                 if (!dn) {
 102                         dev_warn(dev, "Failed to parse %s\n",
 103                                  adj->phandle_name);
 104                         return -ENODEV;
 105                 }
 106                 /* Allow scaling to be disabled on a per-node basis */
 107                 if (!of_device_is_available(dn)) {
 108                         dev_warn(dev, "Missing property %s, skip scaling %s\n",
 109                                  adj->phandle_name, node->name);
 110                         of_node_put(dn);
 111                         return 0;
 112                 }
 113
 114                 pdev = of_find_device_by_node(dn);
 115                 of_node_put(dn);
 116                 if (!pdev) {
 117                         dev_warn(dev, "node %s[%d] missing device for %pOF\n",
 118                                  node->name, node->id, dn);
 119                         return -EPROBE_DEFER;
 120                 }
 121                 node_data->qos_dev = &pdev->dev;
 122                 dev_dbg(dev, "node %s[%d] has device node %pOF\n",
 123                         node->name, node->id, dn);
 124         }
 125
 126         return dev_pm_qos_add_request(node_data->qos_dev,
 127                                       &node_data->qos_req,
 128                                       DEV_PM_QOS_MIN_FREQUENCY, 0);
 129 }
 130
 131 static struct icc_node *imx_icc_node_add(struct icc_provider *provider,
 132                                          const struct imx_icc_node_desc *node_desc)
 133 {
 134         struct device *dev = provider->dev;
 135         struct imx_icc_node *node_data;
 136         struct icc_node *node;
 137         int ret;
 138
 139         node = icc_node_create(node_desc->id);
 140         if (IS_ERR(node)) {
 141                 dev_err(dev, "failed to create node %d\n", node_desc->id);
 142                 return node;
 143         }
 144
 145         if (node->data) {
 146                 dev_err(dev, "already created node %s id=%d\n",
 147                         node_desc->name, node_desc->id);
 148                 return ERR_PTR(-EEXIST);
 149         }
 150
 151         node_data = devm_kzalloc(dev, sizeof(*node_data), GFP_KERNEL);
 152         if (!node_data) {
 153                 icc_node_destroy(node->id);
 154                 return ERR_PTR(-ENOMEM);
 155         }
 156
 157         node->name = node_desc->name;
 158         node->data = node_data;
 159         node_data->desc = node_desc;
 160         icc_node_add(node, provider);
 161
 162         if (node_desc->adj) {
 163                 ret = imx_icc_node_init_qos(provider, node);
 164                 if (ret < 0) {
 165                         imx_icc_node_destroy(node);
 166                         return ERR_PTR(ret);
 167                 }
 168         }
 169
 170         return node;
 171 }
 172
 173 static void imx_icc_unregister_nodes(struct icc_provider *provider)
 174 {
 175         struct icc_node *node, *tmp;
 176
 177         list_for_each_entry_safe(node, tmp, &provider->nodes, node_list)
 178                 imx_icc_node_destroy(node);
 179 }
 180
 181 static int imx_icc_register_nodes(struct icc_provider *provider,
 182                                   const struct imx_icc_node_desc *descs,
 183                                   int count)
 184 {
 185         struct icc_onecell_data *provider_data = provider->data;
 186         int ret;
 187         int i;
 188
 189         for (i = 0; i < count; i++) {
 190                 struct icc_node *node;
 191                 const struct imx_icc_node_desc *node_desc = &descs[i];
 192                 size_t j;
 193
 194                 node = imx_icc_node_add(provider, node_desc);
 195                 if (IS_ERR(node)) {
 196                         ret = dev_err_probe(provider->dev, PTR_ERR(node),
 197                                             "failed to add %s\n", node_desc->name);
 198                         goto err;
 199                 }
 200                 provider_data->nodes[node->id] = node;
 201
 202                 for (j = 0; j < node_desc->num_links; j++) {
 203                         ret = icc_link_create(node, node_desc->links[j]);
 204                         if (ret) {
 205                                 dev_err(provider->dev, "failed to link node %d to %d: %d\n",
 206                                         node->id, node_desc->links[j], ret);
 207                                 goto err;
 208                         }
 209                 }
 210         }
 211
 212         return 0;
 213
 214 err:
 215         imx_icc_unregister_nodes(provider);
 216
 217         return ret;
 218 }
 219
 220 static int get_max_node_id(struct imx_icc_node_desc *nodes, int nodes_count)
 221 {
 222         int i, ret = 0;
 223
 224         for (i = 0; i < nodes_count; ++i)
 225                 if (nodes[i].id > ret)
 226                         ret = nodes[i].id;
 227
 228         return ret;
 229 }
 230
 231 int imx_icc_register(struct platform_device *pdev,
 232                      struct imx_icc_node_desc *nodes, int nodes_count)
 233 {
 234         struct device *dev = &pdev->dev;
 235         struct icc_onecell_data *data;
 236         struct icc_provider *provider;
 237         int max_node_id;
 238         int ret;
 239
 240         /* icc_onecell_data is indexed by node_id, unlike nodes param */
 241         max_node_id = get_max_node_id(nodes, nodes_count);
 242         data = devm_kzalloc(dev, struct_size(data, nodes, max_node_id),
 243                             GFP_KERNEL);
 244         if (!data)
 245                 return -ENOMEM;
 246         data->num_nodes = max_node_id;
 247
 248         provider = devm_kzalloc(dev, sizeof(*provider), GFP_KERNEL);
 249         if (!provider)
 250                 return -ENOMEM;
 251         provider->set = imx_icc_set;
 252         provider->get_bw = imx_icc_get_bw;
 253         provider->aggregate = icc_std_aggregate;
 254         provider->xlate = of_icc_xlate_onecell;
 255         provider->data = data;
 256         provider->dev = dev->parent;
 257         platform_set_drvdata(pdev, provider);
 258
 259         ret = icc_provider_add(provider);
 260         if (ret) {
 261                 dev_err(dev, "error adding interconnect provider: %d\n", ret);
 262                 return ret;
 263         }
 264
 265         ret = imx_icc_register_nodes(provider, nodes, nodes_count);
 266         if (ret)
 267                 goto provider_del;
 268
 269         return 0;
 270
 271 provider_del:
 272         icc_provider_del(provider);
 273         return ret;
 274 }
 275 EXPORT_SYMBOL_GPL(imx_icc_register);
 276
 277 int imx_icc_unregister(struct platform_device *pdev)
 278 {
 279         struct icc_provider *provider = platform_get_drvdata(pdev);
 280
 281         imx_icc_unregister_nodes(provider);
 282
 283         return icc_provider_del(provider);
 284 }
 285 EXPORT_SYMBOL_GPL(imx_icc_unregister);
 286
 287 MODULE_LICENSE("GPL v2");