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 16 #include "lima_device.h" 17 #include "lima_devfreq.h" 18 19 static void lima_devfreq_update_utilization(struct lima_devfreq *devfreq) 20 { 21 ktime_t now, last; 22 23 now = ktime_get(); 24 last = devfreq->time_last_update; 25 26 if (devfreq->busy_count > 0) 27 devfreq->busy_time += ktime_sub(now, last); 28 else 29 devfreq->idle_time += ktime_sub(now, last); 30 31 devfreq->time_last_update = now; 32 } 33 34 static int lima_devfreq_target(struct device *dev, unsigned long *freq, 35 u32 flags) 36 { 37 struct dev_pm_opp *opp; 38 39 opp = devfreq_recommended_opp(dev, freq, flags); 40 if (IS_ERR(opp)) 41 return PTR_ERR(opp); 42 dev_pm_opp_put(opp); 43 44 return dev_pm_opp_set_rate(dev, *freq); 45 } 46 47 static void lima_devfreq_reset(struct lima_devfreq *devfreq) 48 { 49 devfreq->busy_time = 0; 50 devfreq->idle_time = 0; 51 devfreq->time_last_update = ktime_get(); 52 } 53 54 static int lima_devfreq_get_dev_status(struct device *dev, 55 struct devfreq_dev_status *status) 56 { 57 struct lima_device *ldev = dev_get_drvdata(dev); 58 struct lima_devfreq *devfreq = &ldev->devfreq; 59 unsigned long irqflags; 60 61 status->current_frequency = clk_get_rate(ldev->clk_gpu); 62 63 spin_lock_irqsave(&devfreq->lock, irqflags); 64 65 lima_devfreq_update_utilization(devfreq); 66 67 status->total_time = ktime_to_ns(ktime_add(devfreq->busy_time, 68 devfreq->idle_time)); 69 status->busy_time = ktime_to_ns(devfreq->busy_time); 70 71 lima_devfreq_reset(devfreq); 72 73 spin_unlock_irqrestore(&devfreq->lock, irqflags); 74 75 dev_dbg(ldev->dev, "busy %lu total %lu %lu %% freq %lu MHz\n", 76 status->busy_time, status->total_time, 77 status->busy_time / (status->total_time / 100), 78 status->current_frequency / 1000 / 1000); 79 80 return 0; 81 } 82 83 static struct devfreq_dev_profile lima_devfreq_profile = { 84 .timer = DEVFREQ_TIMER_DELAYED, 85 .polling_ms = 50, /* ~3 frames */ 86 .target = lima_devfreq_target, 87 .get_dev_status = lima_devfreq_get_dev_status, 88 }; 89 90 void lima_devfreq_fini(struct lima_device *ldev) 91 { 92 struct lima_devfreq *devfreq = &ldev->devfreq; 93 94 if (devfreq->cooling) { 95 devfreq_cooling_unregister(devfreq->cooling); 96 devfreq->cooling = NULL; 97 } 98 99 if (devfreq->devfreq) { 100 devm_devfreq_remove_device(ldev->dev, devfreq->devfreq); 101 devfreq->devfreq = NULL; 102 } 103 104 dev_pm_opp_of_remove_table(ldev->dev); 105 106 dev_pm_opp_put_regulators(devfreq->regulators_opp_table); 107 dev_pm_opp_put_clkname(devfreq->clkname_opp_table); 108 devfreq->regulators_opp_table = NULL; 109 devfreq->clkname_opp_table = NULL; 110 } 111 112 int lima_devfreq_init(struct lima_device *ldev) 113 { 114 struct thermal_cooling_device *cooling; 115 struct device *dev = ldev->dev; 116 struct opp_table *opp_table; 117 struct devfreq *devfreq; 118 struct lima_devfreq *ldevfreq = &ldev->devfreq; 119 struct dev_pm_opp *opp; 120 unsigned long cur_freq; 121 int ret; 122 123 if (!device_property_present(dev, "operating-points-v2")) 124 /* Optional, continue without devfreq */ 125 return 0; 126 127 spin_lock_init(&ldevfreq->lock); 128 129 opp_table = dev_pm_opp_set_clkname(dev, "core"); 130 if (IS_ERR(opp_table)) { 131 ret = PTR_ERR(opp_table); 132 goto err_fini; 133 } 134 135 ldevfreq->clkname_opp_table = opp_table; 136 137 opp_table = dev_pm_opp_set_regulators(dev, 138 (const char *[]){ "mali" }, 139 1); 140 if (IS_ERR(opp_table)) { 141 ret = PTR_ERR(opp_table); 142 143 /* Continue if the optional regulator is missing */ 144 if (ret != -ENODEV) 145 goto err_fini; 146 } else { 147 ldevfreq->regulators_opp_table = opp_table; 148 } 149 150 ret = dev_pm_opp_of_add_table(dev); 151 if (ret) 152 goto err_fini; 153 154 lima_devfreq_reset(ldevfreq); 155 156 cur_freq = clk_get_rate(ldev->clk_gpu); 157 158 opp = devfreq_recommended_opp(dev, &cur_freq, 0); 159 if (IS_ERR(opp)) { 160 ret = PTR_ERR(opp); 161 goto err_fini; 162 } 163 164 lima_devfreq_profile.initial_freq = cur_freq; 165 dev_pm_opp_put(opp); 166 167 /* 168 * Setup default thresholds for the simple_ondemand governor. 169 * The values are chosen based on experiments. 170 */ 171 ldevfreq->gov_data.upthreshold = 30; 172 ldevfreq->gov_data.downdifferential = 5; 173 174 devfreq = devm_devfreq_add_device(dev, &lima_devfreq_profile, 175 DEVFREQ_GOV_SIMPLE_ONDEMAND, 176 &ldevfreq->gov_data); 177 if (IS_ERR(devfreq)) { 178 dev_err(dev, "Couldn't initialize GPU devfreq\n"); 179 ret = PTR_ERR(devfreq); 180 goto err_fini; 181 } 182 183 ldevfreq->devfreq = devfreq; 184 185 cooling = of_devfreq_cooling_register(dev->of_node, devfreq); 186 if (IS_ERR(cooling)) 187 dev_info(dev, "Failed to register cooling device\n"); 188 else 189 ldevfreq->cooling = cooling; 190 191 return 0; 192 193 err_fini: 194 lima_devfreq_fini(ldev); 195 return ret; 196 } 197 198 void lima_devfreq_record_busy(struct lima_devfreq *devfreq) 199 { 200 unsigned long irqflags; 201 202 if (!devfreq->devfreq) 203 return; 204 205 spin_lock_irqsave(&devfreq->lock, irqflags); 206 207 lima_devfreq_update_utilization(devfreq); 208 209 devfreq->busy_count++; 210 211 spin_unlock_irqrestore(&devfreq->lock, irqflags); 212 } 213 214 void lima_devfreq_record_idle(struct lima_devfreq *devfreq) 215 { 216 unsigned long irqflags; 217 218 if (!devfreq->devfreq) 219 return; 220 221 spin_lock_irqsave(&devfreq->lock, irqflags); 222 223 lima_devfreq_update_utilization(devfreq); 224 225 WARN_ON(--devfreq->busy_count < 0); 226 227 spin_unlock_irqrestore(&devfreq->lock, irqflags); 228 } 229 230 int lima_devfreq_resume(struct lima_devfreq *devfreq) 231 { 232 unsigned long irqflags; 233 234 if (!devfreq->devfreq) 235 return 0; 236 237 spin_lock_irqsave(&devfreq->lock, irqflags); 238 239 lima_devfreq_reset(devfreq); 240 241 spin_unlock_irqrestore(&devfreq->lock, irqflags); 242 243 return devfreq_resume_device(devfreq->devfreq); 244 } 245 246 int lima_devfreq_suspend(struct lima_devfreq *devfreq) 247 { 248 if (!devfreq->devfreq) 249 return 0; 250 251 return devfreq_suspend_device(devfreq->devfreq); 252 } 253