lima_devfreq.c 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright 2020 Martin Blumenstingl <martin.blumenstingl@googlemail.com>
  4. *
  5. * Based on panfrost_devfreq.c:
  6. * Copyright 2019 Collabora ltd.
  7. */
  8. #include <linux/clk.h>
  9. #include <linux/devfreq.h>
  10. #include <linux/devfreq_cooling.h>
  11. #include <linux/device.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/pm_opp.h>
  14. #include <linux/property.h>
  15. #include "lima_device.h"
  16. #include "lima_devfreq.h"
  17. static void lima_devfreq_update_utilization(struct lima_devfreq *devfreq)
  18. {
  19. ktime_t now, last;
  20. now = ktime_get();
  21. last = devfreq->time_last_update;
  22. if (devfreq->busy_count > 0)
  23. devfreq->busy_time += ktime_sub(now, last);
  24. else
  25. devfreq->idle_time += ktime_sub(now, last);
  26. devfreq->time_last_update = now;
  27. }
  28. static int lima_devfreq_target(struct device *dev, unsigned long *freq,
  29. u32 flags)
  30. {
  31. struct dev_pm_opp *opp;
  32. int err;
  33. opp = devfreq_recommended_opp(dev, freq, flags);
  34. if (IS_ERR(opp))
  35. return PTR_ERR(opp);
  36. dev_pm_opp_put(opp);
  37. err = dev_pm_opp_set_rate(dev, *freq);
  38. if (err)
  39. return err;
  40. return 0;
  41. }
  42. static void lima_devfreq_reset(struct lima_devfreq *devfreq)
  43. {
  44. devfreq->busy_time = 0;
  45. devfreq->idle_time = 0;
  46. devfreq->time_last_update = ktime_get();
  47. }
  48. static int lima_devfreq_get_dev_status(struct device *dev,
  49. struct devfreq_dev_status *status)
  50. {
  51. struct lima_device *ldev = dev_get_drvdata(dev);
  52. struct lima_devfreq *devfreq = &ldev->devfreq;
  53. unsigned long irqflags;
  54. status->current_frequency = clk_get_rate(ldev->clk_gpu);
  55. spin_lock_irqsave(&devfreq->lock, irqflags);
  56. lima_devfreq_update_utilization(devfreq);
  57. status->total_time = ktime_to_ns(ktime_add(devfreq->busy_time,
  58. devfreq->idle_time));
  59. status->busy_time = ktime_to_ns(devfreq->busy_time);
  60. lima_devfreq_reset(devfreq);
  61. spin_unlock_irqrestore(&devfreq->lock, irqflags);
  62. dev_dbg(ldev->dev, "busy %lu total %lu %lu %% freq %lu MHz\n",
  63. status->busy_time, status->total_time,
  64. status->busy_time / (status->total_time / 100),
  65. status->current_frequency / 1000 / 1000);
  66. return 0;
  67. }
  68. static struct devfreq_dev_profile lima_devfreq_profile = {
  69. .polling_ms = 50, /* ~3 frames */
  70. .target = lima_devfreq_target,
  71. .get_dev_status = lima_devfreq_get_dev_status,
  72. };
  73. void lima_devfreq_fini(struct lima_device *ldev)
  74. {
  75. struct lima_devfreq *devfreq = &ldev->devfreq;
  76. if (devfreq->cooling) {
  77. devfreq_cooling_unregister(devfreq->cooling);
  78. devfreq->cooling = NULL;
  79. }
  80. if (devfreq->devfreq) {
  81. devm_devfreq_remove_device(ldev->dev, devfreq->devfreq);
  82. devfreq->devfreq = NULL;
  83. }
  84. if (devfreq->opp_of_table_added) {
  85. dev_pm_opp_of_remove_table(ldev->dev);
  86. devfreq->opp_of_table_added = false;
  87. }
  88. if (devfreq->regulators_opp_table) {
  89. dev_pm_opp_put_regulators(devfreq->regulators_opp_table);
  90. devfreq->regulators_opp_table = NULL;
  91. }
  92. if (devfreq->clkname_opp_table) {
  93. dev_pm_opp_put_clkname(devfreq->clkname_opp_table);
  94. devfreq->clkname_opp_table = NULL;
  95. }
  96. }
  97. int lima_devfreq_init(struct lima_device *ldev)
  98. {
  99. struct thermal_cooling_device *cooling;
  100. struct device *dev = ldev->dev;
  101. struct opp_table *opp_table;
  102. struct devfreq *devfreq;
  103. struct lima_devfreq *ldevfreq = &ldev->devfreq;
  104. struct dev_pm_opp *opp;
  105. unsigned long cur_freq;
  106. int ret;
  107. if (!device_property_present(dev, "operating-points-v2"))
  108. /* Optional, continue without devfreq */
  109. return 0;
  110. spin_lock_init(&ldevfreq->lock);
  111. opp_table = dev_pm_opp_set_clkname(dev, "core");
  112. if (IS_ERR(opp_table)) {
  113. ret = PTR_ERR(opp_table);
  114. goto err_fini;
  115. }
  116. ldevfreq->clkname_opp_table = opp_table;
  117. opp_table = dev_pm_opp_set_regulators(dev,
  118. (const char *[]){ "mali" },
  119. 1);
  120. if (IS_ERR(opp_table)) {
  121. ret = PTR_ERR(opp_table);
  122. /* Continue if the optional regulator is missing */
  123. if (ret != -ENODEV)
  124. goto err_fini;
  125. } else {
  126. ldevfreq->regulators_opp_table = opp_table;
  127. }
  128. ret = dev_pm_opp_of_add_table(dev);
  129. if (ret)
  130. goto err_fini;
  131. ldevfreq->opp_of_table_added = true;
  132. lima_devfreq_reset(ldevfreq);
  133. cur_freq = clk_get_rate(ldev->clk_gpu);
  134. opp = devfreq_recommended_opp(dev, &cur_freq, 0);
  135. if (IS_ERR(opp)) {
  136. ret = PTR_ERR(opp);
  137. goto err_fini;
  138. }
  139. lima_devfreq_profile.initial_freq = cur_freq;
  140. dev_pm_opp_put(opp);
  141. devfreq = devm_devfreq_add_device(dev, &lima_devfreq_profile,
  142. DEVFREQ_GOV_SIMPLE_ONDEMAND, NULL);
  143. if (IS_ERR(devfreq)) {
  144. dev_err(dev, "Couldn't initialize GPU devfreq\n");
  145. ret = PTR_ERR(devfreq);
  146. goto err_fini;
  147. }
  148. ldevfreq->devfreq = devfreq;
  149. cooling = of_devfreq_cooling_register(dev->of_node, devfreq);
  150. if (IS_ERR(cooling))
  151. dev_info(dev, "Failed to register cooling device\n");
  152. else
  153. ldevfreq->cooling = cooling;
  154. return 0;
  155. err_fini:
  156. lima_devfreq_fini(ldev);
  157. return ret;
  158. }
  159. void lima_devfreq_record_busy(struct lima_devfreq *devfreq)
  160. {
  161. unsigned long irqflags;
  162. if (!devfreq->devfreq)
  163. return;
  164. spin_lock_irqsave(&devfreq->lock, irqflags);
  165. lima_devfreq_update_utilization(devfreq);
  166. devfreq->busy_count++;
  167. spin_unlock_irqrestore(&devfreq->lock, irqflags);
  168. }
  169. void lima_devfreq_record_idle(struct lima_devfreq *devfreq)
  170. {
  171. unsigned long irqflags;
  172. if (!devfreq->devfreq)
  173. return;
  174. spin_lock_irqsave(&devfreq->lock, irqflags);
  175. lima_devfreq_update_utilization(devfreq);
  176. WARN_ON(--devfreq->busy_count < 0);
  177. spin_unlock_irqrestore(&devfreq->lock, irqflags);
  178. }
  179. int lima_devfreq_resume(struct lima_devfreq *devfreq)
  180. {
  181. unsigned long irqflags;
  182. if (!devfreq->devfreq)
  183. return 0;
  184. spin_lock_irqsave(&devfreq->lock, irqflags);
  185. lima_devfreq_reset(devfreq);
  186. spin_unlock_irqrestore(&devfreq->lock, irqflags);
  187. return devfreq_resume_device(devfreq->devfreq);
  188. }
  189. int lima_devfreq_suspend(struct lima_devfreq *devfreq)
  190. {
  191. if (!devfreq->devfreq)
  192. return 0;
  193. return devfreq_suspend_device(devfreq->devfreq);
  194. }