drivers/cpufreq/scmi-cpufreq.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * System Control and Power Interface (SCMI) based CPUFreq Interface driver
   4  *
   5  * Copyright (C) 2018 ARM Ltd.
   6  * Sudeep Holla <sudeep.holla@arm.com>
   7  */
   8
   9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  10
  11 #include <linux/cpu.h>
  12 #include <linux/cpufreq.h>
  13 #include <linux/cpumask.h>
  14 #include <linux/export.h>
  15 #include <linux/module.h>
  16 #include <linux/pm_opp.h>
  17 #include <linux/slab.h>
  18 #include <linux/scmi_protocol.h>
  19 #include <linux/types.h>
  20
  21 struct scmi_data {
  22         int domain_id;
  23         struct device *cpu_dev;
  24 };
  25
  26 static const struct scmi_handle *handle;
  27
  28 static unsigned int scmi_cpufreq_get_rate(unsigned int cpu)
  29 {
  30         struct cpufreq_policy *policy = cpufreq_cpu_get_raw(cpu);
  31         struct scmi_perf_ops *perf_ops = handle->perf_ops;
  32         struct scmi_data *priv = policy->driver_data;
  33         unsigned long rate;
  34         int ret;
  35
  36         ret = perf_ops->freq_get(handle, priv->domain_id, &rate, false);
  37         if (ret)
  38                 return 0;
  39         return rate / 1000;
  40 }
  41
  42 /*
  43  * perf_ops->freq_set is not a synchronous, the actual OPP change will
  44  * happen asynchronously and can get notified if the events are
  45  * subscribed for by the SCMI firmware
  46  */
  47 static int
  48 scmi_cpufreq_set_target(struct cpufreq_policy *policy, unsigned int index)
  49 {
  50         int ret;
  51         struct scmi_data *priv = policy->driver_data;
  52         struct scmi_perf_ops *perf_ops = handle->perf_ops;
  53         u64 freq = policy->freq_table[index].frequency;
  54
  55         ret = perf_ops->freq_set(handle, priv->domain_id, freq * 1000, false);
  56         if (!ret)
  57                 arch_set_freq_scale(policy->related_cpus, freq,
  58                                     policy->cpuinfo.max_freq);
  59         return ret;
  60 }
  61
  62 static unsigned int scmi_cpufreq_fast_switch(struct cpufreq_policy *policy,
  63                                              unsigned int target_freq)
  64 {
  65         struct scmi_data *priv = policy->driver_data;
  66         struct scmi_perf_ops *perf_ops = handle->perf_ops;
  67
  68         if (!perf_ops->freq_set(handle, priv->domain_id,
  69                                 target_freq * 1000, true)) {
  70                 arch_set_freq_scale(policy->related_cpus, target_freq,
  71                                     policy->cpuinfo.max_freq);
  72                 return target_freq;
  73         }
  74
  75         return 0;
  76 }
  77
  78 static int
  79 scmi_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask)
  80 {
  81         int cpu, domain, tdomain;
  82         struct device *tcpu_dev;
  83
  84         domain = handle->perf_ops->device_domain_id(cpu_dev);
  85         if (domain < 0)
  86                 return domain;
  87
  88         for_each_possible_cpu(cpu) {
  89                 if (cpu == cpu_dev->id)
  90                         continue;
  91
  92                 tcpu_dev = get_cpu_device(cpu);
  93                 if (!tcpu_dev)
  94                         continue;
  95
  96                 tdomain = handle->perf_ops->device_domain_id(tcpu_dev);
  97                 if (tdomain == domain)
  98                         cpumask_set_cpu(cpu, cpumask);
  99         }
 100
 101         return 0;
 102 }
 103
 104 static int scmi_cpufreq_init(struct cpufreq_policy *policy)
 105 {
 106         int ret;
 107         unsigned int latency;
 108         struct device *cpu_dev;
 109         struct scmi_data *priv;
 110         struct cpufreq_frequency_table *freq_table;
 111
 112         cpu_dev = get_cpu_device(policy->cpu);
 113         if (!cpu_dev) {
 114                 pr_err("failed to get cpu%d device\n", policy->cpu);
 115                 return -ENODEV;
 116         }
 117
 118         ret = handle->perf_ops->device_opps_add(handle, cpu_dev);
 119         if (ret) {
 120                 dev_warn(cpu_dev, "failed to add opps to the device\n");
 121                 return ret;
 122         }
 123
 124         ret = scmi_get_sharing_cpus(cpu_dev, policy->cpus);
 125         if (ret) {
 126                 dev_warn(cpu_dev, "failed to get sharing cpumask\n");
 127                 return ret;
 128         }
 129
 130         ret = dev_pm_opp_set_sharing_cpus(cpu_dev, policy->cpus);
 131         if (ret) {
 132                 dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
 133                         __func__, ret);
 134                 return ret;
 135         }
 136
 137         ret = dev_pm_opp_get_opp_count(cpu_dev);
 138         if (ret <= 0) {
 139                 dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
 140                 ret = -EPROBE_DEFER;
 141                 goto out_free_opp;
 142         }
 143
 144         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 145         if (!priv) {
 146                 ret = -ENOMEM;
 147                 goto out_free_opp;
 148         }
 149
 150         ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
 151         if (ret) {
 152                 dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
 153                 goto out_free_priv;
 154         }
 155
 156         priv->cpu_dev = cpu_dev;
 157         priv->domain_id = handle->perf_ops->device_domain_id(cpu_dev);
 158
 159         policy->driver_data = priv;
 160         policy->freq_table = freq_table;
 161
 162         /* SCMI allows DVFS request for any domain from any CPU */
 163         policy->dvfs_possible_from_any_cpu = true;
 164
 165         latency = handle->perf_ops->transition_latency_get(handle, cpu_dev);
 166         if (!latency)
 167                 latency = CPUFREQ_ETERNAL;
 168
 169         policy->cpuinfo.transition_latency = latency;
 170
 171         policy->fast_switch_possible = true;
 172         return 0;
 173
 174 out_free_priv:
 175         kfree(priv);
 176 out_free_opp:
 177         dev_pm_opp_remove_all_dynamic(cpu_dev);
 178
 179         return ret;
 180 }
 181
 182 static int scmi_cpufreq_exit(struct cpufreq_policy *policy)
 183 {
 184         struct scmi_data *priv = policy->driver_data;
 185
 186         dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
 187         dev_pm_opp_remove_all_dynamic(priv->cpu_dev);
 188         kfree(priv);
 189
 190         return 0;
 191 }
 192
 193 static struct cpufreq_driver scmi_cpufreq_driver = {
 194         .name   = "scmi",
 195         .flags  = CPUFREQ_STICKY | CPUFREQ_HAVE_GOVERNOR_PER_POLICY |
 196                   CPUFREQ_NEED_INITIAL_FREQ_CHECK |
 197                   CPUFREQ_IS_COOLING_DEV,
 198         .verify = cpufreq_generic_frequency_table_verify,
 199         .attr   = cpufreq_generic_attr,
 200         .target_index   = scmi_cpufreq_set_target,
 201         .fast_switch    = scmi_cpufreq_fast_switch,
 202         .get    = scmi_cpufreq_get_rate,
 203         .init   = scmi_cpufreq_init,
 204         .exit   = scmi_cpufreq_exit,
 205 };
 206
 207 static int scmi_cpufreq_probe(struct scmi_device *sdev)
 208 {
 209         int ret;
 210
 211         handle = sdev->handle;
 212
 213         if (!handle || !handle->perf_ops)
 214                 return -ENODEV;
 215
 216         ret = cpufreq_register_driver(&scmi_cpufreq_driver);
 217         if (ret) {
 218                 dev_err(&sdev->dev, "%s: registering cpufreq failed, err: %d\n",
 219                         __func__, ret);
 220         }
 221
 222         return ret;
 223 }
 224
 225 static void scmi_cpufreq_remove(struct scmi_device *sdev)
 226 {
 227         cpufreq_unregister_driver(&scmi_cpufreq_driver);
 228 }
 229
 230 static const struct scmi_device_id scmi_id_table[] = {
 231         { SCMI_PROTOCOL_PERF },
 232         { },
 233 };
 234 MODULE_DEVICE_TABLE(scmi, scmi_id_table);
 235
 236 static struct scmi_driver scmi_cpufreq_drv = {
 237         .name           = "scmi-cpufreq",
 238         .probe          = scmi_cpufreq_probe,
 239         .remove         = scmi_cpufreq_remove,
 240         .id_table       = scmi_id_table,
 241 };
 242 module_scmi_driver(scmi_cpufreq_drv);
 243
 244 MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
 245 MODULE_DESCRIPTION("ARM SCMI CPUFreq interface driver");
 246 MODULE_LICENSE("GPL v2");