scmi-cpufreq.c 6.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281
  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. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  9. #include <linux/clk-provider.h>
  10. #include <linux/cpu.h>
  11. #include <linux/cpufreq.h>
  12. #include <linux/cpumask.h>
  13. #include <linux/energy_model.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. struct scmi_data {
  21. int domain_id;
  22. struct device *cpu_dev;
  23. };
  24. static struct scmi_protocol_handle *ph;
  25. static const struct scmi_perf_proto_ops *perf_ops;
  26. static unsigned int scmi_cpufreq_get_rate(unsigned int cpu)
  27. {
  28. struct cpufreq_policy *policy = cpufreq_cpu_get_raw(cpu);
  29. struct scmi_data *priv = policy->driver_data;
  30. unsigned long rate;
  31. int ret;
  32. ret = perf_ops->freq_get(ph, priv->domain_id, &rate, false);
  33. if (ret)
  34. return 0;
  35. return rate / 1000;
  36. }
  37. /*
  38. * perf_ops->freq_set is not a synchronous, the actual OPP change will
  39. * happen asynchronously and can get notified if the events are
  40. * subscribed for by the SCMI firmware
  41. */
  42. static int
  43. scmi_cpufreq_set_target(struct cpufreq_policy *policy, unsigned int index)
  44. {
  45. struct scmi_data *priv = policy->driver_data;
  46. u64 freq = policy->freq_table[index].frequency;
  47. return perf_ops->freq_set(ph, priv->domain_id, freq * 1000, false);
  48. }
  49. static unsigned int scmi_cpufreq_fast_switch(struct cpufreq_policy *policy,
  50. unsigned int target_freq)
  51. {
  52. struct scmi_data *priv = policy->driver_data;
  53. if (!perf_ops->freq_set(ph, priv->domain_id,
  54. target_freq * 1000, true))
  55. return target_freq;
  56. return 0;
  57. }
  58. static int
  59. scmi_get_sharing_cpus(struct device *cpu_dev, struct cpumask *cpumask)
  60. {
  61. int cpu, domain, tdomain;
  62. struct device *tcpu_dev;
  63. domain = perf_ops->device_domain_id(cpu_dev);
  64. if (domain < 0)
  65. return domain;
  66. for_each_possible_cpu(cpu) {
  67. if (cpu == cpu_dev->id)
  68. continue;
  69. tcpu_dev = get_cpu_device(cpu);
  70. if (!tcpu_dev)
  71. continue;
  72. tdomain = perf_ops->device_domain_id(tcpu_dev);
  73. if (tdomain == domain)
  74. cpumask_set_cpu(cpu, cpumask);
  75. }
  76. return 0;
  77. }
  78. static int __maybe_unused
  79. scmi_get_cpu_power(unsigned long *power, unsigned long *KHz,
  80. struct device *cpu_dev)
  81. {
  82. unsigned long Hz;
  83. int ret, domain;
  84. domain = perf_ops->device_domain_id(cpu_dev);
  85. if (domain < 0)
  86. return domain;
  87. /* Get the power cost of the performance domain. */
  88. Hz = *KHz * 1000;
  89. ret = perf_ops->est_power_get(ph, domain, &Hz, power);
  90. if (ret)
  91. return ret;
  92. /* The EM framework specifies the frequency in KHz. */
  93. *KHz = Hz / 1000;
  94. return 0;
  95. }
  96. static int scmi_cpufreq_init(struct cpufreq_policy *policy)
  97. {
  98. int ret, nr_opp;
  99. unsigned int latency;
  100. struct device *cpu_dev;
  101. struct scmi_data *priv;
  102. struct cpufreq_frequency_table *freq_table;
  103. struct em_data_callback em_cb = EM_DATA_CB(scmi_get_cpu_power);
  104. bool power_scale_mw;
  105. cpu_dev = get_cpu_device(policy->cpu);
  106. if (!cpu_dev) {
  107. pr_err("failed to get cpu%d device\n", policy->cpu);
  108. return -ENODEV;
  109. }
  110. ret = perf_ops->device_opps_add(ph, cpu_dev);
  111. if (ret) {
  112. dev_warn(cpu_dev, "failed to add opps to the device\n");
  113. return ret;
  114. }
  115. ret = scmi_get_sharing_cpus(cpu_dev, policy->cpus);
  116. if (ret) {
  117. dev_warn(cpu_dev, "failed to get sharing cpumask\n");
  118. return ret;
  119. }
  120. ret = dev_pm_opp_set_sharing_cpus(cpu_dev, policy->cpus);
  121. if (ret) {
  122. dev_err(cpu_dev, "%s: failed to mark OPPs as shared: %d\n",
  123. __func__, ret);
  124. return ret;
  125. }
  126. nr_opp = dev_pm_opp_get_opp_count(cpu_dev);
  127. if (nr_opp <= 0) {
  128. dev_dbg(cpu_dev, "OPP table is not ready, deferring probe\n");
  129. ret = -EPROBE_DEFER;
  130. goto out_free_opp;
  131. }
  132. priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  133. if (!priv) {
  134. ret = -ENOMEM;
  135. goto out_free_opp;
  136. }
  137. ret = dev_pm_opp_init_cpufreq_table(cpu_dev, &freq_table);
  138. if (ret) {
  139. dev_err(cpu_dev, "failed to init cpufreq table: %d\n", ret);
  140. goto out_free_priv;
  141. }
  142. priv->cpu_dev = cpu_dev;
  143. priv->domain_id = perf_ops->device_domain_id(cpu_dev);
  144. policy->driver_data = priv;
  145. policy->freq_table = freq_table;
  146. /* SCMI allows DVFS request for any domain from any CPU */
  147. policy->dvfs_possible_from_any_cpu = true;
  148. latency = perf_ops->transition_latency_get(ph, cpu_dev);
  149. if (!latency)
  150. latency = CPUFREQ_ETERNAL;
  151. policy->cpuinfo.transition_latency = latency;
  152. policy->fast_switch_possible =
  153. perf_ops->fast_switch_possible(ph, cpu_dev);
  154. power_scale_mw = perf_ops->power_scale_mw_get(ph);
  155. em_dev_register_perf_domain(cpu_dev, nr_opp, &em_cb, policy->cpus,
  156. power_scale_mw);
  157. return 0;
  158. out_free_priv:
  159. kfree(priv);
  160. out_free_opp:
  161. dev_pm_opp_remove_all_dynamic(cpu_dev);
  162. return ret;
  163. }
  164. static int scmi_cpufreq_exit(struct cpufreq_policy *policy)
  165. {
  166. struct scmi_data *priv = policy->driver_data;
  167. dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
  168. dev_pm_opp_remove_all_dynamic(priv->cpu_dev);
  169. kfree(priv);
  170. return 0;
  171. }
  172. static struct cpufreq_driver scmi_cpufreq_driver = {
  173. .name = "scmi",
  174. .flags = CPUFREQ_STICKY | CPUFREQ_HAVE_GOVERNOR_PER_POLICY |
  175. CPUFREQ_NEED_INITIAL_FREQ_CHECK |
  176. CPUFREQ_IS_COOLING_DEV,
  177. .verify = cpufreq_generic_frequency_table_verify,
  178. .attr = cpufreq_generic_attr,
  179. .target_index = scmi_cpufreq_set_target,
  180. .fast_switch = scmi_cpufreq_fast_switch,
  181. .get = scmi_cpufreq_get_rate,
  182. .init = scmi_cpufreq_init,
  183. .exit = scmi_cpufreq_exit,
  184. };
  185. static int scmi_cpufreq_probe(struct scmi_device *sdev)
  186. {
  187. int ret;
  188. struct device *dev = &sdev->dev;
  189. const struct scmi_handle *handle;
  190. handle = sdev->handle;
  191. if (!handle)
  192. return -ENODEV;
  193. perf_ops = handle->devm_get_protocol(sdev, SCMI_PROTOCOL_PERF, &ph);
  194. if (IS_ERR(perf_ops))
  195. return PTR_ERR(perf_ops);
  196. #ifdef CONFIG_COMMON_CLK
  197. /* dummy clock provider as needed by OPP if clocks property is used */
  198. if (of_find_property(dev->of_node, "#clock-cells", NULL))
  199. devm_of_clk_add_hw_provider(dev, of_clk_hw_simple_get, NULL);
  200. #endif
  201. ret = cpufreq_register_driver(&scmi_cpufreq_driver);
  202. if (ret) {
  203. dev_err(dev, "%s: registering cpufreq failed, err: %d\n",
  204. __func__, ret);
  205. }
  206. return ret;
  207. }
  208. static void scmi_cpufreq_remove(struct scmi_device *sdev)
  209. {
  210. cpufreq_unregister_driver(&scmi_cpufreq_driver);
  211. }
  212. static const struct scmi_device_id scmi_id_table[] = {
  213. { SCMI_PROTOCOL_PERF, "cpufreq" },
  214. { },
  215. };
  216. MODULE_DEVICE_TABLE(scmi, scmi_id_table);
  217. static struct scmi_driver scmi_cpufreq_drv = {
  218. .name = "scmi-cpufreq",
  219. .probe = scmi_cpufreq_probe,
  220. .remove = scmi_cpufreq_remove,
  221. .id_table = scmi_id_table,
  222. };
  223. module_scmi_driver(scmi_cpufreq_drv);
  224. MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
  225. MODULE_DESCRIPTION("ARM SCMI CPUFreq interface driver");
  226. MODULE_LICENSE("GPL v2");