interconnect/samsung/exynos.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Exynos generic interconnect provider driver
0004  *
0005  * Copyright (c) 2020 Samsung Electronics Co., Ltd.
0006  *
0007  * Authors: Artur Świgoń <a.swigon@samsung.com>
0008  *          Sylwester Nawrocki <s.nawrocki@samsung.com>
0009  */
0010 #include <linux/device.h>
0011 #include <linux/interconnect-provider.h>
0012 #include <linux/module.h>
0013 #include <linux/of.h>
0014 #include <linux/platform_device.h>
0015 #include <linux/pm_qos.h>
0016 #include <linux/slab.h>
0017
0018 #define EXYNOS_ICC_DEFAULT_BUS_CLK_RATIO    8
0019
0020 struct exynos_icc_priv {
0021     struct device *dev;
0022
0023     /* One interconnect node per provider */
0024     struct icc_provider provider;
0025     struct icc_node *node;
0026
0027     struct dev_pm_qos_request qos_req;
0028     u32 bus_clk_ratio;
0029 };
0030
0031 static struct icc_node *exynos_icc_get_parent(struct device_node *np)
0032 {
0033     struct of_phandle_args args;
0034     struct icc_node_data *icc_node_data;
0035     struct icc_node *icc_node;
0036     int num, ret;
0037
0038     num = of_count_phandle_with_args(np, "interconnects",
0039                      "#interconnect-cells");
0040     if (num < 1)
0041         return NULL; /* parent nodes are optional */
0042
0043     /* Get the interconnect target node */
0044     ret = of_parse_phandle_with_args(np, "interconnects",
0045                     "#interconnect-cells", 0, &args);
0046     if (ret < 0)
0047         return ERR_PTR(ret);
0048
0049     icc_node_data = of_icc_get_from_provider(&args);
0050     of_node_put(args.np);
0051
0052     if (IS_ERR(icc_node_data))
0053         return ERR_CAST(icc_node_data);
0054
0055     icc_node = icc_node_data->node;
0056     kfree(icc_node_data);
0057
0058     return icc_node;
0059 }
0060
0061 static int exynos_generic_icc_set(struct icc_node *src, struct icc_node *dst)
0062 {
0063     struct exynos_icc_priv *src_priv = src->data, *dst_priv = dst->data;
0064     s32 src_freq = max(src->avg_bw, src->peak_bw) / src_priv->bus_clk_ratio;
0065     s32 dst_freq = max(dst->avg_bw, dst->peak_bw) / dst_priv->bus_clk_ratio;
0066     int ret;
0067
0068     ret = dev_pm_qos_update_request(&src_priv->qos_req, src_freq);
0069     if (ret < 0) {
0070         dev_err(src_priv->dev, "failed to update PM QoS of %s (src)\n",
0071             src->name);
0072         return ret;
0073     }
0074
0075     ret = dev_pm_qos_update_request(&dst_priv->qos_req, dst_freq);
0076     if (ret < 0) {
0077         dev_err(dst_priv->dev, "failed to update PM QoS of %s (dst)\n",
0078             dst->name);
0079         return ret;
0080     }
0081
0082     return 0;
0083 }
0084
0085 static struct icc_node *exynos_generic_icc_xlate(struct of_phandle_args *spec,
0086                          void *data)
0087 {
0088     struct exynos_icc_priv *priv = data;
0089
0090     if (spec->np != priv->dev->parent->of_node)
0091         return ERR_PTR(-EINVAL);
0092
0093     return priv->node;
0094 }
0095
0096 static int exynos_generic_icc_remove(struct platform_device *pdev)
0097 {
0098     struct exynos_icc_priv *priv = platform_get_drvdata(pdev);
0099     struct icc_node *parent_node, *node = priv->node;
0100
0101     parent_node = exynos_icc_get_parent(priv->dev->parent->of_node);
0102     if (parent_node && !IS_ERR(parent_node))
0103         icc_link_destroy(node, parent_node);
0104
0105     icc_nodes_remove(&priv->provider);
0106     icc_provider_del(&priv->provider);
0107
0108     return 0;
0109 }
0110
0111 static int exynos_generic_icc_probe(struct platform_device *pdev)
0112 {
0113     struct device *bus_dev = pdev->dev.parent;
0114     struct exynos_icc_priv *priv;
0115     struct icc_provider *provider;
0116     struct icc_node *icc_node, *icc_parent_node;
0117     int ret;
0118
0119     priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
0120     if (!priv)
0121         return -ENOMEM;
0122
0123     priv->dev = &pdev->dev;
0124     platform_set_drvdata(pdev, priv);
0125
0126     provider = &priv->provider;
0127
0128     provider->set = exynos_generic_icc_set;
0129     provider->aggregate = icc_std_aggregate;
0130     provider->xlate = exynos_generic_icc_xlate;
0131     provider->dev = bus_dev;
0132     provider->inter_set = true;
0133     provider->data = priv;
0134
0135     ret = icc_provider_add(provider);
0136     if (ret < 0)
0137         return ret;
0138
0139     icc_node = icc_node_create(pdev->id);
0140     if (IS_ERR(icc_node)) {
0141         ret = PTR_ERR(icc_node);
0142         goto err_prov_del;
0143     }
0144
0145     priv->node = icc_node;
0146     icc_node->name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%pOFn",
0147                     bus_dev->of_node);
0148     if (of_property_read_u32(bus_dev->of_node, "samsung,data-clock-ratio",
0149                  &priv->bus_clk_ratio))
0150         priv->bus_clk_ratio = EXYNOS_ICC_DEFAULT_BUS_CLK_RATIO;
0151
0152     /*
0153      * Register a PM QoS request for the parent (devfreq) device.
0154      */
0155     ret = dev_pm_qos_add_request(bus_dev, &priv->qos_req,
0156                      DEV_PM_QOS_MIN_FREQUENCY, 0);
0157     if (ret < 0)
0158         goto err_node_del;
0159
0160     icc_node->data = priv;
0161     icc_node_add(icc_node, provider);
0162
0163     icc_parent_node = exynos_icc_get_parent(bus_dev->of_node);
0164     if (IS_ERR(icc_parent_node)) {
0165         ret = PTR_ERR(icc_parent_node);
0166         goto err_pmqos_del;
0167     }
0168     if (icc_parent_node) {
0169         ret = icc_link_create(icc_node, icc_parent_node->id);
0170         if (ret < 0)
0171             goto err_pmqos_del;
0172     }
0173
0174     return 0;
0175
0176 err_pmqos_del:
0177     dev_pm_qos_remove_request(&priv->qos_req);
0178 err_node_del:
0179     icc_nodes_remove(provider);
0180 err_prov_del:
0181     icc_provider_del(provider);
0182     return ret;
0183 }
0184
0185 static struct platform_driver exynos_generic_icc_driver = {
0186     .driver = {
0187         .name = "exynos-generic-icc",
0188         .sync_state = icc_sync_state,
0189     },
0190     .probe = exynos_generic_icc_probe,
0191     .remove = exynos_generic_icc_remove,
0192 };
0193 module_platform_driver(exynos_generic_icc_driver);
0194
0195 MODULE_DESCRIPTION("Exynos generic interconnect driver");
0196 MODULE_AUTHOR("Artur Świgoń <a.swigon@samsung.com>");
0197 MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
0198 MODULE_LICENSE("GPL v2");
0199 MODULE_ALIAS("platform:exynos-generic-icc");