Branch data Line data Source code
1 : : /*
2 : : * SPDX-License-Identifier: MIT
3 : : *
4 : : * Copyright © 2019 Intel Corporation
5 : : */
6 : :
7 : : #include "i915_drv.h"
8 : : #include "intel_gt.h"
9 : : #include "intel_gt_irq.h"
10 : : #include "intel_gt_pm_irq.h"
11 : : #include "intel_rps.h"
12 : : #include "intel_sideband.h"
13 : : #include "../../../platform/x86/intel_ips.h"
14 : :
15 : : /*
16 : : * Lock protecting IPS related data structures
17 : : */
18 : : static DEFINE_SPINLOCK(mchdev_lock);
19 : :
20 : 0 : static struct intel_gt *rps_to_gt(struct intel_rps *rps)
21 : : {
22 : 0 : return container_of(rps, struct intel_gt, rps);
23 : : }
24 : :
25 : 0 : static struct drm_i915_private *rps_to_i915(struct intel_rps *rps)
26 : : {
27 [ # # ]: 0 : return rps_to_gt(rps)->i915;
28 : : }
29 : :
30 : 0 : static struct intel_uncore *rps_to_uncore(struct intel_rps *rps)
31 : : {
32 : 0 : return rps_to_gt(rps)->uncore;
33 : : }
34 : :
35 : 0 : static u32 rps_pm_sanitize_mask(struct intel_rps *rps, u32 mask)
36 : : {
37 : 0 : return mask & ~rps->pm_intrmsk_mbz;
38 : : }
39 : :
40 : 0 : static inline void set(struct intel_uncore *uncore, i915_reg_t reg, u32 val)
41 : : {
42 : 0 : intel_uncore_write_fw(uncore, reg, val);
43 : : }
44 : :
45 : 0 : static u32 rps_pm_mask(struct intel_rps *rps, u8 val)
46 : : {
47 : 0 : u32 mask = 0;
48 : :
49 : : /* We use UP_EI_EXPIRED interrupts for both up/down in manual mode */
50 : 0 : if (val > rps->min_freq_softlimit)
51 : 0 : mask |= (GEN6_PM_RP_UP_EI_EXPIRED |
52 : : GEN6_PM_RP_DOWN_THRESHOLD |
53 : : GEN6_PM_RP_DOWN_TIMEOUT);
54 : :
55 [ # # # # ]: 0 : if (val < rps->max_freq_softlimit)
56 : 0 : mask |= GEN6_PM_RP_UP_EI_EXPIRED | GEN6_PM_RP_UP_THRESHOLD;
57 : :
58 : 0 : mask &= rps->pm_events;
59 : :
60 : 0 : return rps_pm_sanitize_mask(rps, ~mask);
61 : : }
62 : :
63 : 0 : static void rps_reset_ei(struct intel_rps *rps)
64 : : {
65 : 0 : memset(&rps->ei, 0, sizeof(rps->ei));
66 : : }
67 : :
68 : 0 : static void rps_enable_interrupts(struct intel_rps *rps)
69 : : {
70 : 0 : struct intel_gt *gt = rps_to_gt(rps);
71 : :
72 : 0 : rps_reset_ei(rps);
73 : :
74 [ # # ]: 0 : if (IS_VALLEYVIEW(gt->i915))
75 : : /* WaGsvRC0ResidencyMethod:vlv */
76 : 0 : rps->pm_events = GEN6_PM_RP_UP_EI_EXPIRED;
77 : : else
78 : 0 : rps->pm_events = (GEN6_PM_RP_UP_THRESHOLD |
79 : : GEN6_PM_RP_DOWN_THRESHOLD |
80 : : GEN6_PM_RP_DOWN_TIMEOUT);
81 : :
82 : 0 : spin_lock_irq(>->irq_lock);
83 : 0 : gen6_gt_pm_enable_irq(gt, rps->pm_events);
84 : 0 : spin_unlock_irq(>->irq_lock);
85 : :
86 [ # # ]: 0 : set(gt->uncore, GEN6_PMINTRMSK, rps_pm_mask(rps, rps->cur_freq));
87 : 0 : }
88 : :
89 : 0 : static void gen6_rps_reset_interrupts(struct intel_rps *rps)
90 : : {
91 : 0 : gen6_gt_pm_reset_iir(rps_to_gt(rps), GEN6_PM_RPS_EVENTS);
92 : 0 : }
93 : :
94 : : static void gen11_rps_reset_interrupts(struct intel_rps *rps)
95 : : {
96 [ # # ]: 0 : while (gen11_gt_reset_one_iir(rps_to_gt(rps), 0, GEN11_GTPM))
97 : 0 : ;
98 : : }
99 : :
100 : 0 : static void rps_reset_interrupts(struct intel_rps *rps)
101 : : {
102 : 0 : struct intel_gt *gt = rps_to_gt(rps);
103 : :
104 : 0 : spin_lock_irq(>->irq_lock);
105 [ # # ]: 0 : if (INTEL_GEN(gt->i915) >= 11)
106 : : gen11_rps_reset_interrupts(rps);
107 : : else
108 : 0 : gen6_rps_reset_interrupts(rps);
109 : :
110 : 0 : rps->pm_iir = 0;
111 : 0 : spin_unlock_irq(>->irq_lock);
112 : 0 : }
113 : :
114 : 0 : static void rps_disable_interrupts(struct intel_rps *rps)
115 : : {
116 : 0 : struct intel_gt *gt = rps_to_gt(rps);
117 : :
118 : 0 : rps->pm_events = 0;
119 : :
120 : 0 : set(gt->uncore, GEN6_PMINTRMSK, rps_pm_sanitize_mask(rps, ~0u));
121 : :
122 : 0 : spin_lock_irq(>->irq_lock);
123 : 0 : gen6_gt_pm_disable_irq(gt, GEN6_PM_RPS_EVENTS);
124 : 0 : spin_unlock_irq(>->irq_lock);
125 : :
126 : 0 : intel_synchronize_irq(gt->i915);
127 : :
128 : : /*
129 : : * Now that we will not be generating any more work, flush any
130 : : * outstanding tasks. As we are called on the RPS idle path,
131 : : * we will reset the GPU to minimum frequencies, so the current
132 : : * state of the worker can be discarded.
133 : : */
134 : 0 : cancel_work_sync(&rps->work);
135 : :
136 : 0 : rps_reset_interrupts(rps);
137 : 0 : }
138 : :
139 : : static const struct cparams {
140 : : u16 i;
141 : : u16 t;
142 : : u16 m;
143 : : u16 c;
144 : : } cparams[] = {
145 : : { 1, 1333, 301, 28664 },
146 : : { 1, 1066, 294, 24460 },
147 : : { 1, 800, 294, 25192 },
148 : : { 0, 1333, 276, 27605 },
149 : : { 0, 1066, 276, 27605 },
150 : : { 0, 800, 231, 23784 },
151 : : };
152 : :
153 : 0 : static void gen5_rps_init(struct intel_rps *rps)
154 : : {
155 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
156 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
157 : 0 : u8 fmax, fmin, fstart;
158 : 0 : u32 rgvmodectl;
159 : 0 : int c_m, i;
160 : :
161 [ # # ]: 0 : if (i915->fsb_freq <= 3200)
162 : : c_m = 0;
163 [ # # ]: 0 : else if (i915->fsb_freq <= 4800)
164 : : c_m = 1;
165 : : else
166 : 0 : c_m = 2;
167 : :
168 [ # # ]: 0 : for (i = 0; i < ARRAY_SIZE(cparams); i++) {
169 [ # # # # ]: 0 : if (cparams[i].i == c_m && cparams[i].t == i915->mem_freq) {
170 : 0 : rps->ips.m = cparams[i].m;
171 : 0 : rps->ips.c = cparams[i].c;
172 : 0 : break;
173 : : }
174 : : }
175 : :
176 : 0 : rgvmodectl = intel_uncore_read(uncore, MEMMODECTL);
177 : :
178 : : /* Set up min, max, and cur for interrupt handling */
179 : 0 : fmax = (rgvmodectl & MEMMODE_FMAX_MASK) >> MEMMODE_FMAX_SHIFT;
180 : 0 : fmin = (rgvmodectl & MEMMODE_FMIN_MASK);
181 : 0 : fstart = (rgvmodectl & MEMMODE_FSTART_MASK) >>
182 : : MEMMODE_FSTART_SHIFT;
183 : 0 : DRM_DEBUG_DRIVER("fmax: %d, fmin: %d, fstart: %d\n",
184 : : fmax, fmin, fstart);
185 : :
186 : 0 : rps->min_freq = fmax;
187 : 0 : rps->max_freq = fmin;
188 : :
189 : 0 : rps->idle_freq = rps->min_freq;
190 : 0 : rps->cur_freq = rps->idle_freq;
191 : 0 : }
192 : :
193 : : static unsigned long
194 : 0 : __ips_chipset_val(struct intel_ips *ips)
195 : : {
196 : 0 : struct intel_uncore *uncore =
197 : 0 : rps_to_uncore(container_of(ips, struct intel_rps, ips));
198 : 0 : unsigned long now = jiffies_to_msecs(jiffies), dt;
199 : 0 : unsigned long result;
200 : 0 : u64 total, delta;
201 : :
202 : 0 : lockdep_assert_held(&mchdev_lock);
203 : :
204 : : /*
205 : : * Prevent division-by-zero if we are asking too fast.
206 : : * Also, we don't get interesting results if we are polling
207 : : * faster than once in 10ms, so just return the saved value
208 : : * in such cases.
209 : : */
210 : 0 : dt = now - ips->last_time1;
211 [ # # ]: 0 : if (dt <= 10)
212 : 0 : return ips->chipset_power;
213 : :
214 : : /* FIXME: handle per-counter overflow */
215 : 0 : total = intel_uncore_read(uncore, DMIEC);
216 : 0 : total += intel_uncore_read(uncore, DDREC);
217 : 0 : total += intel_uncore_read(uncore, CSIEC);
218 : :
219 : 0 : delta = total - ips->last_count1;
220 : :
221 : 0 : result = div_u64(div_u64(ips->m * delta, dt) + ips->c, 10);
222 : :
223 : 0 : ips->last_count1 = total;
224 : 0 : ips->last_time1 = now;
225 : :
226 : 0 : ips->chipset_power = result;
227 : :
228 : 0 : return result;
229 : : }
230 : :
231 : 0 : static unsigned long ips_mch_val(struct intel_uncore *uncore)
232 : : {
233 : 0 : unsigned int m, x, b;
234 : 0 : u32 tsfs;
235 : :
236 : 0 : tsfs = intel_uncore_read(uncore, TSFS);
237 : 0 : x = intel_uncore_read8(uncore, TR1);
238 : :
239 : 0 : b = tsfs & TSFS_INTR_MASK;
240 : 0 : m = (tsfs & TSFS_SLOPE_MASK) >> TSFS_SLOPE_SHIFT;
241 : :
242 : 0 : return m * x / 127 - b;
243 : : }
244 : :
245 : 0 : static int _pxvid_to_vd(u8 pxvid)
246 : : {
247 : 0 : if (pxvid == 0)
248 : : return 0;
249 : :
250 [ # # ]: 0 : if (pxvid >= 8 && pxvid < 31)
251 : 0 : pxvid = 31;
252 : :
253 : 0 : return (pxvid + 2) * 125;
254 : : }
255 : :
256 : 0 : static u32 pvid_to_extvid(struct drm_i915_private *i915, u8 pxvid)
257 : : {
258 : 0 : const int vd = _pxvid_to_vd(pxvid);
259 : :
260 [ # # ]: 0 : if (INTEL_INFO(i915)->is_mobile)
261 : 0 : return max(vd - 1125, 0);
262 : :
263 : 0 : return vd;
264 : : }
265 : :
266 : 0 : static void __gen5_ips_update(struct intel_ips *ips)
267 : : {
268 : 0 : struct intel_uncore *uncore =
269 : 0 : rps_to_uncore(container_of(ips, struct intel_rps, ips));
270 : 0 : u64 now, delta, dt;
271 : 0 : u32 count;
272 : :
273 : 0 : lockdep_assert_held(&mchdev_lock);
274 : :
275 : 0 : now = ktime_get_raw_ns();
276 : 0 : dt = now - ips->last_time2;
277 : 0 : do_div(dt, NSEC_PER_MSEC);
278 : :
279 : : /* Don't divide by 0 */
280 [ # # ]: 0 : if (dt <= 10)
281 : : return;
282 : :
283 : 0 : count = intel_uncore_read(uncore, GFXEC);
284 : 0 : delta = count - ips->last_count2;
285 : :
286 : 0 : ips->last_count2 = count;
287 : 0 : ips->last_time2 = now;
288 : :
289 : : /* More magic constants... */
290 : 0 : ips->gfx_power = div_u64(delta * 1181, dt * 10);
291 : : }
292 : :
293 : 0 : static void gen5_rps_update(struct intel_rps *rps)
294 : : {
295 : 0 : spin_lock_irq(&mchdev_lock);
296 : 0 : __gen5_ips_update(&rps->ips);
297 : 0 : spin_unlock_irq(&mchdev_lock);
298 : 0 : }
299 : :
300 : 0 : static bool gen5_rps_set(struct intel_rps *rps, u8 val)
301 : : {
302 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
303 : 0 : u16 rgvswctl;
304 : :
305 : 0 : lockdep_assert_held(&mchdev_lock);
306 : :
307 : 0 : rgvswctl = intel_uncore_read16(uncore, MEMSWCTL);
308 [ # # ]: 0 : if (rgvswctl & MEMCTL_CMD_STS) {
309 : 0 : DRM_DEBUG("gpu busy, RCS change rejected\n");
310 : 0 : return false; /* still busy with another command */
311 : : }
312 : :
313 : : /* Invert the frequency bin into an ips delay */
314 : 0 : val = rps->max_freq - val;
315 : 0 : val = rps->min_freq + val;
316 : :
317 : 0 : rgvswctl =
318 : : (MEMCTL_CMD_CHFREQ << MEMCTL_CMD_SHIFT) |
319 : 0 : (val << MEMCTL_FREQ_SHIFT) |
320 : : MEMCTL_SFCAVM;
321 : 0 : intel_uncore_write16(uncore, MEMSWCTL, rgvswctl);
322 : 0 : intel_uncore_posting_read16(uncore, MEMSWCTL);
323 : :
324 : 0 : rgvswctl |= MEMCTL_CMD_STS;
325 : 0 : intel_uncore_write16(uncore, MEMSWCTL, rgvswctl);
326 : :
327 : 0 : return true;
328 : : }
329 : :
330 : 0 : static unsigned long intel_pxfreq(u32 vidfreq)
331 : : {
332 : 0 : int div = (vidfreq & 0x3f0000) >> 16;
333 : 0 : int post = (vidfreq & 0x3000) >> 12;
334 : 0 : int pre = (vidfreq & 0x7);
335 : :
336 : 0 : if (!pre)
337 : : return 0;
338 : :
339 : 0 : return div * 133333 / (pre << post);
340 : : }
341 : :
342 : 0 : static unsigned int init_emon(struct intel_uncore *uncore)
343 : : {
344 : 0 : u8 pxw[16];
345 : 0 : int i;
346 : :
347 : : /* Disable to program */
348 : 0 : intel_uncore_write(uncore, ECR, 0);
349 : 0 : intel_uncore_posting_read(uncore, ECR);
350 : :
351 : : /* Program energy weights for various events */
352 : 0 : intel_uncore_write(uncore, SDEW, 0x15040d00);
353 : 0 : intel_uncore_write(uncore, CSIEW0, 0x007f0000);
354 : 0 : intel_uncore_write(uncore, CSIEW1, 0x1e220004);
355 : 0 : intel_uncore_write(uncore, CSIEW2, 0x04000004);
356 : :
357 [ # # ]: 0 : for (i = 0; i < 5; i++)
358 : 0 : intel_uncore_write(uncore, PEW(i), 0);
359 [ # # ]: 0 : for (i = 0; i < 3; i++)
360 : 0 : intel_uncore_write(uncore, DEW(i), 0);
361 : :
362 : : /* Program P-state weights to account for frequency power adjustment */
363 [ # # ]: 0 : for (i = 0; i < 16; i++) {
364 : 0 : u32 pxvidfreq = intel_uncore_read(uncore, PXVFREQ(i));
365 [ # # ]: 0 : unsigned int freq = intel_pxfreq(pxvidfreq);
366 : 0 : unsigned int vid =
367 : 0 : (pxvidfreq & PXVFREQ_PX_MASK) >> PXVFREQ_PX_SHIFT;
368 : 0 : unsigned int val;
369 : :
370 : 0 : val = vid * vid * freq / 1000 * 255;
371 : 0 : val /= 127 * 127 * 900;
372 : :
373 : 0 : pxw[i] = val;
374 : : }
375 : : /* Render standby states get 0 weight */
376 : 0 : pxw[14] = 0;
377 : 0 : pxw[15] = 0;
378 : :
379 [ # # ]: 0 : for (i = 0; i < 4; i++) {
380 : 0 : intel_uncore_write(uncore, PXW(i),
381 : 0 : pxw[i * 4 + 0] << 24 |
382 : 0 : pxw[i * 4 + 1] << 16 |
383 : 0 : pxw[i * 4 + 2] << 8 |
384 : 0 : pxw[i * 4 + 3] << 0);
385 : : }
386 : :
387 : : /* Adjust magic regs to magic values (more experimental results) */
388 : 0 : intel_uncore_write(uncore, OGW0, 0);
389 : 0 : intel_uncore_write(uncore, OGW1, 0);
390 : 0 : intel_uncore_write(uncore, EG0, 0x00007f00);
391 : 0 : intel_uncore_write(uncore, EG1, 0x0000000e);
392 : 0 : intel_uncore_write(uncore, EG2, 0x000e0000);
393 : 0 : intel_uncore_write(uncore, EG3, 0x68000300);
394 : 0 : intel_uncore_write(uncore, EG4, 0x42000000);
395 : 0 : intel_uncore_write(uncore, EG5, 0x00140031);
396 : 0 : intel_uncore_write(uncore, EG6, 0);
397 : 0 : intel_uncore_write(uncore, EG7, 0);
398 : :
399 [ # # ]: 0 : for (i = 0; i < 8; i++)
400 : 0 : intel_uncore_write(uncore, PXWL(i), 0);
401 : :
402 : : /* Enable PMON + select events */
403 : 0 : intel_uncore_write(uncore, ECR, 0x80000019);
404 : :
405 : 0 : return intel_uncore_read(uncore, LCFUSE02) & LCFUSE_HIV_MASK;
406 : : }
407 : :
408 : 0 : static bool gen5_rps_enable(struct intel_rps *rps)
409 : : {
410 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
411 : 0 : u8 fstart, vstart;
412 : 0 : u32 rgvmodectl;
413 : :
414 : 0 : spin_lock_irq(&mchdev_lock);
415 : :
416 : 0 : rgvmodectl = intel_uncore_read(uncore, MEMMODECTL);
417 : :
418 : : /* Enable temp reporting */
419 : 0 : intel_uncore_write16(uncore, PMMISC,
420 : 0 : intel_uncore_read16(uncore, PMMISC) | MCPPCE_EN);
421 : 0 : intel_uncore_write16(uncore, TSC1,
422 : 0 : intel_uncore_read16(uncore, TSC1) | TSE);
423 : :
424 : : /* 100ms RC evaluation intervals */
425 : 0 : intel_uncore_write(uncore, RCUPEI, 100000);
426 : 0 : intel_uncore_write(uncore, RCDNEI, 100000);
427 : :
428 : : /* Set max/min thresholds to 90ms and 80ms respectively */
429 : 0 : intel_uncore_write(uncore, RCBMAXAVG, 90000);
430 : 0 : intel_uncore_write(uncore, RCBMINAVG, 80000);
431 : :
432 : 0 : intel_uncore_write(uncore, MEMIHYST, 1);
433 : :
434 : : /* Set up min, max, and cur for interrupt handling */
435 : 0 : fstart = (rgvmodectl & MEMMODE_FSTART_MASK) >>
436 : : MEMMODE_FSTART_SHIFT;
437 : :
438 : 0 : vstart = (intel_uncore_read(uncore, PXVFREQ(fstart)) &
439 : 0 : PXVFREQ_PX_MASK) >> PXVFREQ_PX_SHIFT;
440 : :
441 : 0 : intel_uncore_write(uncore,
442 : : MEMINTREN,
443 : : MEMINT_CX_SUPR_EN | MEMINT_EVAL_CHG_EN);
444 : :
445 : 0 : intel_uncore_write(uncore, VIDSTART, vstart);
446 : 0 : intel_uncore_posting_read(uncore, VIDSTART);
447 : :
448 : 0 : rgvmodectl |= MEMMODE_SWMODE_EN;
449 : 0 : intel_uncore_write(uncore, MEMMODECTL, rgvmodectl);
450 : :
451 [ # # # # : 0 : if (wait_for_atomic((intel_uncore_read(uncore, MEMSWCTL) &
# # ]
452 : : MEMCTL_CMD_STS) == 0, 10))
453 : 0 : DRM_ERROR("stuck trying to change perf mode\n");
454 : 0 : mdelay(1);
455 : :
456 : 0 : gen5_rps_set(rps, rps->cur_freq);
457 : :
458 : 0 : rps->ips.last_count1 = intel_uncore_read(uncore, DMIEC);
459 : 0 : rps->ips.last_count1 += intel_uncore_read(uncore, DDREC);
460 : 0 : rps->ips.last_count1 += intel_uncore_read(uncore, CSIEC);
461 : 0 : rps->ips.last_time1 = jiffies_to_msecs(jiffies);
462 : :
463 : 0 : rps->ips.last_count2 = intel_uncore_read(uncore, GFXEC);
464 : 0 : rps->ips.last_time2 = ktime_get_raw_ns();
465 : :
466 : 0 : spin_unlock_irq(&mchdev_lock);
467 : :
468 : 0 : rps->ips.corr = init_emon(uncore);
469 : :
470 : 0 : return true;
471 : : }
472 : :
473 : 0 : static void gen5_rps_disable(struct intel_rps *rps)
474 : : {
475 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
476 : 0 : u16 rgvswctl;
477 : :
478 : 0 : spin_lock_irq(&mchdev_lock);
479 : :
480 : 0 : rgvswctl = intel_uncore_read16(uncore, MEMSWCTL);
481 : :
482 : : /* Ack interrupts, disable EFC interrupt */
483 : 0 : intel_uncore_write(uncore, MEMINTREN,
484 : 0 : intel_uncore_read(uncore, MEMINTREN) &
485 : : ~MEMINT_EVAL_CHG_EN);
486 : 0 : intel_uncore_write(uncore, MEMINTRSTS, MEMINT_EVAL_CHG);
487 : 0 : intel_uncore_write(uncore, DEIER,
488 : 0 : intel_uncore_read(uncore, DEIER) & ~DE_PCU_EVENT);
489 : 0 : intel_uncore_write(uncore, DEIIR, DE_PCU_EVENT);
490 : 0 : intel_uncore_write(uncore, DEIMR,
491 : 0 : intel_uncore_read(uncore, DEIMR) | DE_PCU_EVENT);
492 : :
493 : : /* Go back to the starting frequency */
494 : 0 : gen5_rps_set(rps, rps->idle_freq);
495 : 0 : mdelay(1);
496 : 0 : rgvswctl |= MEMCTL_CMD_STS;
497 : 0 : intel_uncore_write(uncore, MEMSWCTL, rgvswctl);
498 : 0 : mdelay(1);
499 : :
500 : 0 : spin_unlock_irq(&mchdev_lock);
501 : 0 : }
502 : :
503 : 0 : static u32 rps_limits(struct intel_rps *rps, u8 val)
504 : : {
505 : 0 : u32 limits;
506 : :
507 : : /*
508 : : * Only set the down limit when we've reached the lowest level to avoid
509 : : * getting more interrupts, otherwise leave this clear. This prevents a
510 : : * race in the hw when coming out of rc6: There's a tiny window where
511 : : * the hw runs at the minimal clock before selecting the desired
512 : : * frequency, if the down threshold expires in that window we will not
513 : : * receive a down interrupt.
514 : : */
515 : 0 : if (INTEL_GEN(rps_to_i915(rps)) >= 9) {
516 : 0 : limits = rps->max_freq_softlimit << 23;
517 [ # # ]: 0 : if (val <= rps->min_freq_softlimit)
518 : 0 : limits |= rps->min_freq_softlimit << 14;
519 : : } else {
520 : 0 : limits = rps->max_freq_softlimit << 24;
521 [ # # ]: 0 : if (val <= rps->min_freq_softlimit)
522 : 0 : limits |= rps->min_freq_softlimit << 16;
523 : : }
524 : :
525 : 0 : return limits;
526 : : }
527 : :
528 : 0 : static void rps_set_power(struct intel_rps *rps, int new_power)
529 : : {
530 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
531 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
532 : 0 : u32 threshold_up = 0, threshold_down = 0; /* in % */
533 : 0 : u32 ei_up = 0, ei_down = 0;
534 : :
535 : 0 : lockdep_assert_held(&rps->power.mutex);
536 : :
537 [ # # ]: 0 : if (new_power == rps->power.mode)
538 : : return;
539 : :
540 : : /* Note the units here are not exactly 1us, but 1280ns. */
541 [ # # ]: 0 : switch (new_power) {
542 : : case LOW_POWER:
543 : : /* Upclock if more than 95% busy over 16ms */
544 : : ei_up = 16000;
545 : : threshold_up = 95;
546 : :
547 : : /* Downclock if less than 85% busy over 32ms */
548 : : ei_down = 32000;
549 : : threshold_down = 85;
550 : : break;
551 : :
552 : : case BETWEEN:
553 : : /* Upclock if more than 90% busy over 13ms */
554 : : ei_up = 13000;
555 : : threshold_up = 90;
556 : :
557 : : /* Downclock if less than 75% busy over 32ms */
558 : : ei_down = 32000;
559 : : threshold_down = 75;
560 : : break;
561 : :
562 : : case HIGH_POWER:
563 : : /* Upclock if more than 85% busy over 10ms */
564 : : ei_up = 10000;
565 : : threshold_up = 85;
566 : :
567 : : /* Downclock if less than 60% busy over 32ms */
568 : : ei_down = 32000;
569 : : threshold_down = 60;
570 : : break;
571 : : }
572 : :
573 : : /* When byt can survive without system hang with dynamic
574 : : * sw freq adjustments, this restriction can be lifted.
575 : : */
576 [ # # ]: 0 : if (IS_VALLEYVIEW(i915))
577 : 0 : goto skip_hw_write;
578 : :
579 [ # # # # : 0 : set(uncore, GEN6_RP_UP_EI, GT_INTERVAL_FROM_US(i915, ei_up));
# # ]
580 : 0 : set(uncore, GEN6_RP_UP_THRESHOLD,
581 [ # # # # : 0 : GT_INTERVAL_FROM_US(i915, ei_up * threshold_up / 100));
# # ]
582 : :
583 [ # # # # : 0 : set(uncore, GEN6_RP_DOWN_EI, GT_INTERVAL_FROM_US(i915, ei_down));
# # ]
584 : 0 : set(uncore, GEN6_RP_DOWN_THRESHOLD,
585 [ # # # # : 0 : GT_INTERVAL_FROM_US(i915, ei_down * threshold_down / 100));
# # ]
586 : :
587 : 0 : set(uncore, GEN6_RP_CONTROL,
588 [ # # ]: 0 : (INTEL_GEN(i915) > 9 ? 0 : GEN6_RP_MEDIA_TURBO) |
589 : : GEN6_RP_MEDIA_HW_NORMAL_MODE |
590 : : GEN6_RP_MEDIA_IS_GFX |
591 : : GEN6_RP_ENABLE |
592 : : GEN6_RP_UP_BUSY_AVG |
593 : : GEN6_RP_DOWN_IDLE_AVG);
594 : :
595 : 0 : skip_hw_write:
596 : 0 : rps->power.mode = new_power;
597 : 0 : rps->power.up_threshold = threshold_up;
598 : 0 : rps->power.down_threshold = threshold_down;
599 : : }
600 : :
601 : 0 : static void gen6_rps_set_thresholds(struct intel_rps *rps, u8 val)
602 : : {
603 : 0 : int new_power;
604 : :
605 : 0 : new_power = rps->power.mode;
606 [ # # # # ]: 0 : switch (rps->power.mode) {
607 : 0 : case LOW_POWER:
608 [ # # ]: 0 : if (val > rps->efficient_freq + 1 &&
609 [ # # ]: 0 : val > rps->cur_freq)
610 : 0 : new_power = BETWEEN;
611 : : break;
612 : :
613 : 0 : case BETWEEN:
614 [ # # ]: 0 : if (val <= rps->efficient_freq &&
615 [ # # ]: 0 : val < rps->cur_freq)
616 : : new_power = LOW_POWER;
617 [ # # ]: 0 : else if (val >= rps->rp0_freq &&
618 [ # # ]: 0 : val > rps->cur_freq)
619 : 0 : new_power = HIGH_POWER;
620 : : break;
621 : :
622 : 0 : case HIGH_POWER:
623 [ # # ]: 0 : if (val < (rps->rp1_freq + rps->rp0_freq) >> 1 &&
624 [ # # ]: 0 : val < rps->cur_freq)
625 : 0 : new_power = BETWEEN;
626 : : break;
627 : : }
628 : : /* Max/min bins are special */
629 [ # # ]: 0 : if (val <= rps->min_freq_softlimit)
630 : 0 : new_power = LOW_POWER;
631 [ # # ]: 0 : if (val >= rps->max_freq_softlimit)
632 : 0 : new_power = HIGH_POWER;
633 : :
634 : 0 : mutex_lock(&rps->power.mutex);
635 [ # # ]: 0 : if (rps->power.interactive)
636 : 0 : new_power = HIGH_POWER;
637 : 0 : rps_set_power(rps, new_power);
638 : 0 : mutex_unlock(&rps->power.mutex);
639 : 0 : }
640 : :
641 : 0 : void intel_rps_mark_interactive(struct intel_rps *rps, bool interactive)
642 : : {
643 : 0 : mutex_lock(&rps->power.mutex);
644 [ # # ]: 0 : if (interactive) {
645 [ # # # # ]: 0 : if (!rps->power.interactive++ && rps->active)
646 : 0 : rps_set_power(rps, HIGH_POWER);
647 : : } else {
648 : 0 : GEM_BUG_ON(!rps->power.interactive);
649 : 0 : rps->power.interactive--;
650 : : }
651 : 0 : mutex_unlock(&rps->power.mutex);
652 : 0 : }
653 : :
654 : 0 : static int gen6_rps_set(struct intel_rps *rps, u8 val)
655 : : {
656 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
657 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
658 : 0 : u32 swreq;
659 : :
660 : 0 : if (INTEL_GEN(i915) >= 9)
661 : 0 : swreq = GEN9_FREQUENCY(val);
662 [ # # # # ]: 0 : else if (IS_HASWELL(i915) || IS_BROADWELL(i915))
663 : 0 : swreq = HSW_FREQUENCY(val);
664 : : else
665 : 0 : swreq = (GEN6_FREQUENCY(val) |
666 : 0 : GEN6_OFFSET(0) |
667 : : GEN6_AGGRESSIVE_TURBO);
668 : 0 : set(uncore, GEN6_RPNSWREQ, swreq);
669 : :
670 : 0 : return 0;
671 : : }
672 : :
673 : 0 : static int vlv_rps_set(struct intel_rps *rps, u8 val)
674 : : {
675 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
676 : 0 : int err;
677 : :
678 : 0 : vlv_punit_get(i915);
679 : 0 : err = vlv_punit_write(i915, PUNIT_REG_GPU_FREQ_REQ, val);
680 : 0 : vlv_punit_put(i915);
681 : :
682 : 0 : return err;
683 : : }
684 : :
685 : 0 : static int rps_set(struct intel_rps *rps, u8 val, bool update)
686 : : {
687 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
688 : 0 : int err;
689 : :
690 [ # # ]: 0 : if (INTEL_GEN(i915) < 6)
691 : : return 0;
692 : :
693 [ # # ]: 0 : if (val == rps->last_freq)
694 : : return 0;
695 : :
696 [ # # # # ]: 0 : if (IS_VALLEYVIEW(i915) || IS_CHERRYVIEW(i915))
697 : 0 : err = vlv_rps_set(rps, val);
698 : : else
699 [ # # ]: 0 : err = gen6_rps_set(rps, val);
700 [ # # ]: 0 : if (err)
701 : : return err;
702 : :
703 [ # # ]: 0 : if (update)
704 : 0 : gen6_rps_set_thresholds(rps, val);
705 : 0 : rps->last_freq = val;
706 : :
707 : 0 : return 0;
708 : : }
709 : :
710 : 0 : void intel_rps_unpark(struct intel_rps *rps)
711 : : {
712 : 0 : u8 freq;
713 : :
714 [ # # ]: 0 : if (!rps->enabled)
715 : : return;
716 : :
717 : : /*
718 : : * Use the user's desired frequency as a guide, but for better
719 : : * performance, jump directly to RPe as our starting frequency.
720 : : */
721 : 0 : mutex_lock(&rps->lock);
722 : 0 : rps->active = true;
723 : 0 : freq = max(rps->cur_freq, rps->efficient_freq),
724 : 0 : freq = clamp(freq, rps->min_freq_softlimit, rps->max_freq_softlimit);
725 : 0 : intel_rps_set(rps, freq);
726 : 0 : rps->last_adj = 0;
727 : 0 : mutex_unlock(&rps->lock);
728 : :
729 [ # # ]: 0 : if (INTEL_GEN(rps_to_i915(rps)) >= 6)
730 : 0 : rps_enable_interrupts(rps);
731 : :
732 [ # # ]: 0 : if (IS_GEN(rps_to_i915(rps), 5))
733 : 0 : gen5_rps_update(rps);
734 : : }
735 : :
736 : 0 : void intel_rps_park(struct intel_rps *rps)
737 : : {
738 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
739 : :
740 [ # # ]: 0 : if (!rps->enabled)
741 : : return;
742 : :
743 [ # # ]: 0 : if (INTEL_GEN(i915) >= 6)
744 : 0 : rps_disable_interrupts(rps);
745 : :
746 : 0 : rps->active = false;
747 [ # # ]: 0 : if (rps->last_freq <= rps->idle_freq)
748 : : return;
749 : :
750 : : /*
751 : : * The punit delays the write of the frequency and voltage until it
752 : : * determines the GPU is awake. During normal usage we don't want to
753 : : * waste power changing the frequency if the GPU is sleeping (rc6).
754 : : * However, the GPU and driver is now idle and we do not want to delay
755 : : * switching to minimum voltage (reducing power whilst idle) as we do
756 : : * not expect to be woken in the near future and so must flush the
757 : : * change by waking the device.
758 : : *
759 : : * We choose to take the media powerwell (either would do to trick the
760 : : * punit into committing the voltage change) as that takes a lot less
761 : : * power than the render powerwell.
762 : : */
763 : 0 : intel_uncore_forcewake_get(rps_to_uncore(rps), FORCEWAKE_MEDIA);
764 : 0 : rps_set(rps, rps->idle_freq, false);
765 : 0 : intel_uncore_forcewake_put(rps_to_uncore(rps), FORCEWAKE_MEDIA);
766 : : }
767 : :
768 : 0 : void intel_rps_boost(struct i915_request *rq)
769 : : {
770 : 0 : struct intel_rps *rps = &rq->engine->gt->rps;
771 : 0 : unsigned long flags;
772 : :
773 [ # # # # ]: 0 : if (i915_request_signaled(rq) || !rps->active)
774 : : return;
775 : :
776 : : /* Serializes with i915_request_retire() */
777 : 0 : spin_lock_irqsave(&rq->lock, flags);
778 [ # # # # ]: 0 : if (!i915_request_has_waitboost(rq) &&
779 : 0 : !dma_fence_is_signaled_locked(&rq->fence)) {
780 : 0 : set_bit(I915_FENCE_FLAG_BOOST, &rq->fence.flags);
781 : :
782 [ # # # # ]: 0 : if (!atomic_fetch_inc(&rps->num_waiters) &&
783 [ # # ]: 0 : READ_ONCE(rps->cur_freq) < rps->boost_freq)
784 : 0 : schedule_work(&rps->work);
785 : :
786 : 0 : atomic_inc(&rps->boosts);
787 : : }
788 : 0 : spin_unlock_irqrestore(&rq->lock, flags);
789 : : }
790 : :
791 : 0 : int intel_rps_set(struct intel_rps *rps, u8 val)
792 : : {
793 : 0 : int err;
794 : :
795 : 0 : lockdep_assert_held(&rps->lock);
796 : 0 : GEM_BUG_ON(val > rps->max_freq);
797 : 0 : GEM_BUG_ON(val < rps->min_freq);
798 : :
799 [ # # ]: 0 : if (rps->active) {
800 : 0 : err = rps_set(rps, val, true);
801 [ # # ]: 0 : if (err)
802 : : return err;
803 : :
804 : : /*
805 : : * Make sure we continue to get interrupts
806 : : * until we hit the minimum or maximum frequencies.
807 : : */
808 [ # # ]: 0 : if (INTEL_GEN(rps_to_i915(rps)) >= 6) {
809 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
810 : :
811 [ # # ]: 0 : set(uncore,
812 : : GEN6_RP_INTERRUPT_LIMITS, rps_limits(rps, val));
813 : :
814 [ # # ]: 0 : set(uncore, GEN6_PMINTRMSK, rps_pm_mask(rps, val));
815 : : }
816 : : }
817 : :
818 : 0 : rps->cur_freq = val;
819 : 0 : return 0;
820 : : }
821 : :
822 : 0 : static void gen6_rps_init(struct intel_rps *rps)
823 : : {
824 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
825 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
826 : :
827 : : /* All of these values are in units of 50MHz */
828 : :
829 : : /* static values from HW: RP0 > RP1 > RPn (min_freq) */
830 [ # # # # ]: 0 : if (IS_GEN9_LP(i915)) {
831 : 0 : u32 rp_state_cap = intel_uncore_read(uncore, BXT_RP_STATE_CAP);
832 : :
833 : 0 : rps->rp0_freq = (rp_state_cap >> 16) & 0xff;
834 : 0 : rps->rp1_freq = (rp_state_cap >> 8) & 0xff;
835 : 0 : rps->min_freq = (rp_state_cap >> 0) & 0xff;
836 : : } else {
837 : 0 : u32 rp_state_cap = intel_uncore_read(uncore, GEN6_RP_STATE_CAP);
838 : :
839 : 0 : rps->rp0_freq = (rp_state_cap >> 0) & 0xff;
840 : 0 : rps->rp1_freq = (rp_state_cap >> 8) & 0xff;
841 : 0 : rps->min_freq = (rp_state_cap >> 16) & 0xff;
842 : : }
843 : :
844 : : /* hw_max = RP0 until we check for overclocking */
845 : 0 : rps->max_freq = rps->rp0_freq;
846 : :
847 : 0 : rps->efficient_freq = rps->rp1_freq;
848 [ # # # # ]: 0 : if (IS_HASWELL(i915) || IS_BROADWELL(i915) ||
849 [ # # # # : 0 : IS_GEN9_BC(i915) || INTEL_GEN(i915) >= 10) {
# # ]
850 : 0 : u32 ddcc_status = 0;
851 : :
852 [ # # ]: 0 : if (sandybridge_pcode_read(i915,
853 : : HSW_PCODE_DYNAMIC_DUTY_CYCLE_CONTROL,
854 : : &ddcc_status, NULL) == 0)
855 : 0 : rps->efficient_freq =
856 : 0 : clamp_t(u8,
857 : : (ddcc_status >> 8) & 0xff,
858 : : rps->min_freq,
859 : : rps->max_freq);
860 : : }
861 : :
862 [ # # # # : 0 : if (IS_GEN9_BC(i915) || INTEL_GEN(i915) >= 10) {
# # ]
863 : : /* Store the frequency values in 16.66 MHZ units, which is
864 : : * the natural hardware unit for SKL
865 : : */
866 : 0 : rps->rp0_freq *= GEN9_FREQ_SCALER;
867 : 0 : rps->rp1_freq *= GEN9_FREQ_SCALER;
868 : 0 : rps->min_freq *= GEN9_FREQ_SCALER;
869 : 0 : rps->max_freq *= GEN9_FREQ_SCALER;
870 : 0 : rps->efficient_freq *= GEN9_FREQ_SCALER;
871 : : }
872 : 0 : }
873 : :
874 : 0 : static bool rps_reset(struct intel_rps *rps)
875 : : {
876 : : /* force a reset */
877 : 0 : rps->power.mode = -1;
878 : 0 : rps->last_freq = -1;
879 : :
880 [ # # ]: 0 : if (rps_set(rps, rps->min_freq, true)) {
881 : 0 : DRM_ERROR("Failed to reset RPS to initial values\n");
882 : 0 : return false;
883 : : }
884 : :
885 : 0 : rps->cur_freq = rps->min_freq;
886 : 0 : return true;
887 : : }
888 : :
889 : : /* See the Gen9_GT_PM_Programming_Guide doc for the below */
890 : 0 : static bool gen9_rps_enable(struct intel_rps *rps)
891 : : {
892 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
893 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
894 : :
895 : : /* Program defaults and thresholds for RPS */
896 [ # # ]: 0 : if (IS_GEN(i915, 9))
897 : 0 : intel_uncore_write_fw(uncore, GEN6_RC_VIDEO_FREQ,
898 : : GEN9_FREQUENCY(rps->rp1_freq));
899 : :
900 : : /* 1 second timeout */
901 [ # # # # : 0 : intel_uncore_write_fw(uncore, GEN6_RP_DOWN_TIMEOUT,
# # ]
902 : : GT_INTERVAL_FROM_US(i915, 1000000));
903 : :
904 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_IDLE_HYSTERSIS, 0xa);
905 : :
906 : 0 : return rps_reset(rps);
907 : : }
908 : :
909 : 0 : static bool gen8_rps_enable(struct intel_rps *rps)
910 : : {
911 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
912 : :
913 : 0 : intel_uncore_write_fw(uncore, GEN6_RC_VIDEO_FREQ,
914 : : HSW_FREQUENCY(rps->rp1_freq));
915 : :
916 : : /* NB: Docs say 1s, and 1000000 - which aren't equivalent */
917 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_DOWN_TIMEOUT,
918 : : 100000000 / 128); /* 1 second timeout */
919 : :
920 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_IDLE_HYSTERSIS, 10);
921 : :
922 : 0 : return rps_reset(rps);
923 : : }
924 : :
925 : 0 : static bool gen6_rps_enable(struct intel_rps *rps)
926 : : {
927 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
928 : :
929 : : /* Power down if completely idle for over 50ms */
930 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_DOWN_TIMEOUT, 50000);
931 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_IDLE_HYSTERSIS, 10);
932 : :
933 : 0 : return rps_reset(rps);
934 : : }
935 : :
936 : 0 : static int chv_rps_max_freq(struct intel_rps *rps)
937 : : {
938 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
939 : 0 : u32 val;
940 : :
941 : 0 : val = vlv_punit_read(i915, FB_GFX_FMAX_AT_VMAX_FUSE);
942 : :
943 [ # # # ]: 0 : switch (RUNTIME_INFO(i915)->sseu.eu_total) {
944 : 0 : case 8:
945 : : /* (2 * 4) config */
946 : 0 : val >>= FB_GFX_FMAX_AT_VMAX_2SS4EU_FUSE_SHIFT;
947 : 0 : break;
948 : 0 : case 12:
949 : : /* (2 * 6) config */
950 : 0 : val >>= FB_GFX_FMAX_AT_VMAX_2SS6EU_FUSE_SHIFT;
951 : 0 : break;
952 : 0 : case 16:
953 : : /* (2 * 8) config */
954 : : default:
955 : : /* Setting (2 * 8) Min RP0 for any other combination */
956 : 0 : val >>= FB_GFX_FMAX_AT_VMAX_2SS8EU_FUSE_SHIFT;
957 : 0 : break;
958 : : }
959 : :
960 : 0 : return val & FB_GFX_FREQ_FUSE_MASK;
961 : : }
962 : :
963 : 0 : static int chv_rps_rpe_freq(struct intel_rps *rps)
964 : : {
965 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
966 : 0 : u32 val;
967 : :
968 : 0 : val = vlv_punit_read(i915, PUNIT_GPU_DUTYCYCLE_REG);
969 : 0 : val >>= PUNIT_GPU_DUTYCYCLE_RPE_FREQ_SHIFT;
970 : :
971 : 0 : return val & PUNIT_GPU_DUTYCYCLE_RPE_FREQ_MASK;
972 : : }
973 : :
974 : 0 : static int chv_rps_guar_freq(struct intel_rps *rps)
975 : : {
976 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
977 : 0 : u32 val;
978 : :
979 : 0 : val = vlv_punit_read(i915, FB_GFX_FMAX_AT_VMAX_FUSE);
980 : :
981 : 0 : return val & FB_GFX_FREQ_FUSE_MASK;
982 : : }
983 : :
984 : 0 : static u32 chv_rps_min_freq(struct intel_rps *rps)
985 : : {
986 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
987 : 0 : u32 val;
988 : :
989 : 0 : val = vlv_punit_read(i915, FB_GFX_FMIN_AT_VMIN_FUSE);
990 : 0 : val >>= FB_GFX_FMIN_AT_VMIN_FUSE_SHIFT;
991 : :
992 : 0 : return val & FB_GFX_FREQ_FUSE_MASK;
993 : : }
994 : :
995 : 0 : static bool chv_rps_enable(struct intel_rps *rps)
996 : : {
997 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
998 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
999 : 0 : u32 val;
1000 : :
1001 : : /* 1: Program defaults and thresholds for RPS*/
1002 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_DOWN_TIMEOUT, 1000000);
1003 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_UP_THRESHOLD, 59400);
1004 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_DOWN_THRESHOLD, 245000);
1005 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_UP_EI, 66000);
1006 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_DOWN_EI, 350000);
1007 : :
1008 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_IDLE_HYSTERSIS, 10);
1009 : :
1010 : : /* 2: Enable RPS */
1011 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_CONTROL,
1012 : : GEN6_RP_MEDIA_HW_NORMAL_MODE |
1013 : : GEN6_RP_MEDIA_IS_GFX |
1014 : : GEN6_RP_ENABLE |
1015 : : GEN6_RP_UP_BUSY_AVG |
1016 : : GEN6_RP_DOWN_IDLE_AVG);
1017 : :
1018 : : /* Setting Fixed Bias */
1019 : 0 : vlv_punit_get(i915);
1020 : :
1021 : 0 : val = VLV_OVERRIDE_EN | VLV_SOC_TDP_EN | CHV_BIAS_CPU_50_SOC_50;
1022 : 0 : vlv_punit_write(i915, VLV_TURBO_SOC_OVERRIDE, val);
1023 : :
1024 : 0 : val = vlv_punit_read(i915, PUNIT_REG_GPU_FREQ_STS);
1025 : :
1026 : 0 : vlv_punit_put(i915);
1027 : :
1028 : : /* RPS code assumes GPLL is used */
1029 [ # # # # ]: 0 : WARN_ONCE((val & GPLLENABLE) == 0, "GPLL not enabled\n");
1030 : :
1031 [ # # ]: 0 : DRM_DEBUG_DRIVER("GPLL enabled? %s\n", yesno(val & GPLLENABLE));
1032 : 0 : DRM_DEBUG_DRIVER("GPU status: 0x%08x\n", val);
1033 : :
1034 : 0 : return rps_reset(rps);
1035 : : }
1036 : :
1037 : 0 : static int vlv_rps_guar_freq(struct intel_rps *rps)
1038 : : {
1039 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1040 : 0 : u32 val, rp1;
1041 : :
1042 : 0 : val = vlv_nc_read(i915, IOSF_NC_FB_GFX_FREQ_FUSE);
1043 : :
1044 : 0 : rp1 = val & FB_GFX_FGUARANTEED_FREQ_FUSE_MASK;
1045 : 0 : rp1 >>= FB_GFX_FGUARANTEED_FREQ_FUSE_SHIFT;
1046 : :
1047 : 0 : return rp1;
1048 : : }
1049 : :
1050 : 0 : static int vlv_rps_max_freq(struct intel_rps *rps)
1051 : : {
1052 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1053 : 0 : u32 val, rp0;
1054 : :
1055 : 0 : val = vlv_nc_read(i915, IOSF_NC_FB_GFX_FREQ_FUSE);
1056 : :
1057 : 0 : rp0 = (val & FB_GFX_MAX_FREQ_FUSE_MASK) >> FB_GFX_MAX_FREQ_FUSE_SHIFT;
1058 : : /* Clamp to max */
1059 : 0 : rp0 = min_t(u32, rp0, 0xea);
1060 : :
1061 : 0 : return rp0;
1062 : : }
1063 : :
1064 : 0 : static int vlv_rps_rpe_freq(struct intel_rps *rps)
1065 : : {
1066 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1067 : 0 : u32 val, rpe;
1068 : :
1069 : 0 : val = vlv_nc_read(i915, IOSF_NC_FB_GFX_FMAX_FUSE_LO);
1070 : 0 : rpe = (val & FB_FMAX_VMIN_FREQ_LO_MASK) >> FB_FMAX_VMIN_FREQ_LO_SHIFT;
1071 : 0 : val = vlv_nc_read(i915, IOSF_NC_FB_GFX_FMAX_FUSE_HI);
1072 : 0 : rpe |= (val & FB_FMAX_VMIN_FREQ_HI_MASK) << 5;
1073 : :
1074 : 0 : return rpe;
1075 : : }
1076 : :
1077 : 0 : static int vlv_rps_min_freq(struct intel_rps *rps)
1078 : : {
1079 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1080 : 0 : u32 val;
1081 : :
1082 : 0 : val = vlv_punit_read(i915, PUNIT_REG_GPU_LFM) & 0xff;
1083 : : /*
1084 : : * According to the BYT Punit GPU turbo HAS 1.1.6.3 the minimum value
1085 : : * for the minimum frequency in GPLL mode is 0xc1. Contrary to this on
1086 : : * a BYT-M B0 the above register contains 0xbf. Moreover when setting
1087 : : * a frequency Punit will not allow values below 0xc0. Clamp it 0xc0
1088 : : * to make sure it matches what Punit accepts.
1089 : : */
1090 : 0 : return max_t(u32, val, 0xc0);
1091 : : }
1092 : :
1093 : 0 : static bool vlv_rps_enable(struct intel_rps *rps)
1094 : : {
1095 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
1096 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1097 : 0 : u32 val;
1098 : :
1099 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_DOWN_TIMEOUT, 1000000);
1100 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_UP_THRESHOLD, 59400);
1101 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_DOWN_THRESHOLD, 245000);
1102 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_UP_EI, 66000);
1103 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_DOWN_EI, 350000);
1104 : :
1105 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_IDLE_HYSTERSIS, 10);
1106 : :
1107 : 0 : intel_uncore_write_fw(uncore, GEN6_RP_CONTROL,
1108 : : GEN6_RP_MEDIA_TURBO |
1109 : : GEN6_RP_MEDIA_HW_NORMAL_MODE |
1110 : : GEN6_RP_MEDIA_IS_GFX |
1111 : : GEN6_RP_ENABLE |
1112 : : GEN6_RP_UP_BUSY_AVG |
1113 : : GEN6_RP_DOWN_IDLE_CONT);
1114 : :
1115 : 0 : vlv_punit_get(i915);
1116 : :
1117 : : /* Setting Fixed Bias */
1118 : 0 : val = VLV_OVERRIDE_EN | VLV_SOC_TDP_EN | VLV_BIAS_CPU_125_SOC_875;
1119 : 0 : vlv_punit_write(i915, VLV_TURBO_SOC_OVERRIDE, val);
1120 : :
1121 : 0 : val = vlv_punit_read(i915, PUNIT_REG_GPU_FREQ_STS);
1122 : :
1123 : 0 : vlv_punit_put(i915);
1124 : :
1125 : : /* RPS code assumes GPLL is used */
1126 [ # # # # ]: 0 : WARN_ONCE((val & GPLLENABLE) == 0, "GPLL not enabled\n");
1127 : :
1128 [ # # ]: 0 : DRM_DEBUG_DRIVER("GPLL enabled? %s\n", yesno(val & GPLLENABLE));
1129 : 0 : DRM_DEBUG_DRIVER("GPU status: 0x%08x\n", val);
1130 : :
1131 : 0 : return rps_reset(rps);
1132 : : }
1133 : :
1134 : 0 : static unsigned long __ips_gfx_val(struct intel_ips *ips)
1135 : : {
1136 : 0 : struct intel_rps *rps = container_of(ips, typeof(*rps), ips);
1137 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
1138 : 0 : unsigned long t, corr, state1, corr2, state2;
1139 : 0 : u32 pxvid, ext_v;
1140 : :
1141 : 0 : lockdep_assert_held(&mchdev_lock);
1142 : :
1143 : 0 : pxvid = intel_uncore_read(uncore, PXVFREQ(rps->cur_freq));
1144 : 0 : pxvid = (pxvid >> 24) & 0x7f;
1145 [ # # ]: 0 : ext_v = pvid_to_extvid(rps_to_i915(rps), pxvid);
1146 : :
1147 : 0 : state1 = ext_v;
1148 : :
1149 : : /* Revel in the empirically derived constants */
1150 : :
1151 : : /* Correction factor in 1/100000 units */
1152 : 0 : t = ips_mch_val(uncore);
1153 [ # # ]: 0 : if (t > 80)
1154 : 0 : corr = t * 2349 + 135940;
1155 [ # # ]: 0 : else if (t >= 50)
1156 : 0 : corr = t * 964 + 29317;
1157 : : else /* < 50 */
1158 : 0 : corr = t * 301 + 1004;
1159 : :
1160 : 0 : corr = corr * 150142 * state1 / 10000 - 78642;
1161 : 0 : corr /= 100000;
1162 : 0 : corr2 = corr * ips->corr;
1163 : :
1164 : 0 : state2 = corr2 * state1 / 10000;
1165 : 0 : state2 /= 100; /* convert to mW */
1166 : :
1167 : 0 : __gen5_ips_update(ips);
1168 : :
1169 : 0 : return ips->gfx_power + state2;
1170 : : }
1171 : :
1172 : 0 : void intel_rps_enable(struct intel_rps *rps)
1173 : : {
1174 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1175 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
1176 : :
1177 : 0 : intel_uncore_forcewake_get(uncore, FORCEWAKE_ALL);
1178 [ # # ]: 0 : if (IS_CHERRYVIEW(i915))
1179 : 0 : rps->enabled = chv_rps_enable(rps);
1180 [ # # ]: 0 : else if (IS_VALLEYVIEW(i915))
1181 : 0 : rps->enabled = vlv_rps_enable(rps);
1182 [ # # ]: 0 : else if (INTEL_GEN(i915) >= 9)
1183 : 0 : rps->enabled = gen9_rps_enable(rps);
1184 [ # # ]: 0 : else if (INTEL_GEN(i915) >= 8)
1185 : 0 : rps->enabled = gen8_rps_enable(rps);
1186 [ # # ]: 0 : else if (INTEL_GEN(i915) >= 6)
1187 : 0 : rps->enabled = gen6_rps_enable(rps);
1188 [ # # # # ]: 0 : else if (IS_IRONLAKE_M(i915))
1189 : 0 : rps->enabled = gen5_rps_enable(rps);
1190 : 0 : intel_uncore_forcewake_put(uncore, FORCEWAKE_ALL);
1191 [ # # ]: 0 : if (!rps->enabled)
1192 : : return;
1193 : :
1194 [ # # ]: 0 : WARN_ON(rps->max_freq < rps->min_freq);
1195 [ # # ]: 0 : WARN_ON(rps->idle_freq > rps->max_freq);
1196 : :
1197 [ # # ]: 0 : WARN_ON(rps->efficient_freq < rps->min_freq);
1198 [ # # ]: 0 : WARN_ON(rps->efficient_freq > rps->max_freq);
1199 : : }
1200 : :
1201 : 0 : static void gen6_rps_disable(struct intel_rps *rps)
1202 : : {
1203 : 0 : set(rps_to_uncore(rps), GEN6_RP_CONTROL, 0);
1204 : 0 : }
1205 : :
1206 : 0 : void intel_rps_disable(struct intel_rps *rps)
1207 : : {
1208 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1209 : :
1210 : 0 : rps->enabled = false;
1211 : :
1212 [ # # ]: 0 : if (INTEL_GEN(i915) >= 6)
1213 : 0 : gen6_rps_disable(rps);
1214 [ # # # # ]: 0 : else if (IS_IRONLAKE_M(i915))
1215 : 0 : gen5_rps_disable(rps);
1216 : 0 : }
1217 : :
1218 : 0 : static int byt_gpu_freq(struct intel_rps *rps, int val)
1219 : : {
1220 : : /*
1221 : : * N = val - 0xb7
1222 : : * Slow = Fast = GPLL ref * N
1223 : : */
1224 : 0 : return DIV_ROUND_CLOSEST(rps->gpll_ref_freq * (val - 0xb7), 1000);
1225 : : }
1226 : :
1227 : 0 : static int byt_freq_opcode(struct intel_rps *rps, int val)
1228 : : {
1229 : 0 : return DIV_ROUND_CLOSEST(1000 * val, rps->gpll_ref_freq) + 0xb7;
1230 : : }
1231 : :
1232 : 0 : static int chv_gpu_freq(struct intel_rps *rps, int val)
1233 : : {
1234 : : /*
1235 : : * N = val / 2
1236 : : * CU (slow) = CU2x (fast) / 2 = GPLL ref * N / 2
1237 : : */
1238 : 0 : return DIV_ROUND_CLOSEST(rps->gpll_ref_freq * val, 2 * 2 * 1000);
1239 : : }
1240 : :
1241 : 0 : static int chv_freq_opcode(struct intel_rps *rps, int val)
1242 : : {
1243 : : /* CHV needs even values */
1244 : 0 : return DIV_ROUND_CLOSEST(2 * 1000 * val, rps->gpll_ref_freq) * 2;
1245 : : }
1246 : :
1247 : 0 : int intel_gpu_freq(struct intel_rps *rps, int val)
1248 : : {
1249 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1250 : :
1251 [ # # ]: 0 : if (INTEL_GEN(i915) >= 9)
1252 [ # # ]: 0 : return DIV_ROUND_CLOSEST(val * GT_FREQUENCY_MULTIPLIER,
1253 : : GEN9_FREQ_SCALER);
1254 [ # # ]: 0 : else if (IS_CHERRYVIEW(i915))
1255 [ # # ]: 0 : return chv_gpu_freq(rps, val);
1256 [ # # ]: 0 : else if (IS_VALLEYVIEW(i915))
1257 [ # # ]: 0 : return byt_gpu_freq(rps, val);
1258 : : else
1259 : 0 : return val * GT_FREQUENCY_MULTIPLIER;
1260 : : }
1261 : :
1262 : 0 : int intel_freq_opcode(struct intel_rps *rps, int val)
1263 : : {
1264 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1265 : :
1266 [ # # ]: 0 : if (INTEL_GEN(i915) >= 9)
1267 [ # # ]: 0 : return DIV_ROUND_CLOSEST(val * GEN9_FREQ_SCALER,
1268 : : GT_FREQUENCY_MULTIPLIER);
1269 [ # # ]: 0 : else if (IS_CHERRYVIEW(i915))
1270 : 0 : return chv_freq_opcode(rps, val);
1271 [ # # ]: 0 : else if (IS_VALLEYVIEW(i915))
1272 : 0 : return byt_freq_opcode(rps, val);
1273 : : else
1274 [ # # ]: 0 : return DIV_ROUND_CLOSEST(val, GT_FREQUENCY_MULTIPLIER);
1275 : : }
1276 : :
1277 : 0 : static void vlv_init_gpll_ref_freq(struct intel_rps *rps)
1278 : : {
1279 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1280 : :
1281 : 0 : rps->gpll_ref_freq =
1282 : 0 : vlv_get_cck_clock(i915, "GPLL ref",
1283 : : CCK_GPLL_CLOCK_CONTROL,
1284 : 0 : i915->czclk_freq);
1285 : :
1286 : 0 : DRM_DEBUG_DRIVER("GPLL reference freq: %d kHz\n", rps->gpll_ref_freq);
1287 : 0 : }
1288 : :
1289 : 0 : static void vlv_rps_init(struct intel_rps *rps)
1290 : : {
1291 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1292 : 0 : u32 val;
1293 : :
1294 : 0 : vlv_iosf_sb_get(i915,
1295 : : BIT(VLV_IOSF_SB_PUNIT) |
1296 : : BIT(VLV_IOSF_SB_NC) |
1297 : : BIT(VLV_IOSF_SB_CCK));
1298 : :
1299 : 0 : vlv_init_gpll_ref_freq(rps);
1300 : :
1301 : 0 : val = vlv_punit_read(i915, PUNIT_REG_GPU_FREQ_STS);
1302 [ # # # ]: 0 : switch ((val >> 6) & 3) {
1303 : 0 : case 0:
1304 : : case 1:
1305 : 0 : i915->mem_freq = 800;
1306 : 0 : break;
1307 : 0 : case 2:
1308 : 0 : i915->mem_freq = 1066;
1309 : 0 : break;
1310 : 0 : case 3:
1311 : 0 : i915->mem_freq = 1333;
1312 : 0 : break;
1313 : : }
1314 : 0 : DRM_DEBUG_DRIVER("DDR speed: %d MHz\n", i915->mem_freq);
1315 : :
1316 : 0 : rps->max_freq = vlv_rps_max_freq(rps);
1317 : 0 : rps->rp0_freq = rps->max_freq;
1318 : 0 : DRM_DEBUG_DRIVER("max GPU freq: %d MHz (%u)\n",
1319 : : intel_gpu_freq(rps, rps->max_freq),
1320 : : rps->max_freq);
1321 : :
1322 : 0 : rps->efficient_freq = vlv_rps_rpe_freq(rps);
1323 : 0 : DRM_DEBUG_DRIVER("RPe GPU freq: %d MHz (%u)\n",
1324 : : intel_gpu_freq(rps, rps->efficient_freq),
1325 : : rps->efficient_freq);
1326 : :
1327 : 0 : rps->rp1_freq = vlv_rps_guar_freq(rps);
1328 : 0 : DRM_DEBUG_DRIVER("RP1(Guar Freq) GPU freq: %d MHz (%u)\n",
1329 : : intel_gpu_freq(rps, rps->rp1_freq),
1330 : : rps->rp1_freq);
1331 : :
1332 : 0 : rps->min_freq = vlv_rps_min_freq(rps);
1333 : 0 : DRM_DEBUG_DRIVER("min GPU freq: %d MHz (%u)\n",
1334 : : intel_gpu_freq(rps, rps->min_freq),
1335 : : rps->min_freq);
1336 : :
1337 : 0 : vlv_iosf_sb_put(i915,
1338 : : BIT(VLV_IOSF_SB_PUNIT) |
1339 : : BIT(VLV_IOSF_SB_NC) |
1340 : : BIT(VLV_IOSF_SB_CCK));
1341 : 0 : }
1342 : :
1343 : 0 : static void chv_rps_init(struct intel_rps *rps)
1344 : : {
1345 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1346 : 0 : u32 val;
1347 : :
1348 : 0 : vlv_iosf_sb_get(i915,
1349 : : BIT(VLV_IOSF_SB_PUNIT) |
1350 : : BIT(VLV_IOSF_SB_NC) |
1351 : : BIT(VLV_IOSF_SB_CCK));
1352 : :
1353 : 0 : vlv_init_gpll_ref_freq(rps);
1354 : :
1355 : 0 : val = vlv_cck_read(i915, CCK_FUSE_REG);
1356 : :
1357 [ # # ]: 0 : switch ((val >> 2) & 0x7) {
1358 : 0 : case 3:
1359 : 0 : i915->mem_freq = 2000;
1360 : 0 : break;
1361 : 0 : default:
1362 : 0 : i915->mem_freq = 1600;
1363 : 0 : break;
1364 : : }
1365 : 0 : DRM_DEBUG_DRIVER("DDR speed: %d MHz\n", i915->mem_freq);
1366 : :
1367 : 0 : rps->max_freq = chv_rps_max_freq(rps);
1368 : 0 : rps->rp0_freq = rps->max_freq;
1369 : 0 : DRM_DEBUG_DRIVER("max GPU freq: %d MHz (%u)\n",
1370 : : intel_gpu_freq(rps, rps->max_freq),
1371 : : rps->max_freq);
1372 : :
1373 : 0 : rps->efficient_freq = chv_rps_rpe_freq(rps);
1374 : 0 : DRM_DEBUG_DRIVER("RPe GPU freq: %d MHz (%u)\n",
1375 : : intel_gpu_freq(rps, rps->efficient_freq),
1376 : : rps->efficient_freq);
1377 : :
1378 : 0 : rps->rp1_freq = chv_rps_guar_freq(rps);
1379 : 0 : DRM_DEBUG_DRIVER("RP1(Guar) GPU freq: %d MHz (%u)\n",
1380 : : intel_gpu_freq(rps, rps->rp1_freq),
1381 : : rps->rp1_freq);
1382 : :
1383 : 0 : rps->min_freq = chv_rps_min_freq(rps);
1384 : 0 : DRM_DEBUG_DRIVER("min GPU freq: %d MHz (%u)\n",
1385 : : intel_gpu_freq(rps, rps->min_freq),
1386 : : rps->min_freq);
1387 : :
1388 : 0 : vlv_iosf_sb_put(i915,
1389 : : BIT(VLV_IOSF_SB_PUNIT) |
1390 : : BIT(VLV_IOSF_SB_NC) |
1391 : : BIT(VLV_IOSF_SB_CCK));
1392 : :
1393 [ # # # # ]: 0 : WARN_ONCE((rps->max_freq | rps->efficient_freq | rps->rp1_freq |
1394 : : rps->min_freq) & 1,
1395 : : "Odd GPU freq values\n");
1396 : 0 : }
1397 : :
1398 : 0 : static void vlv_c0_read(struct intel_uncore *uncore, struct intel_rps_ei *ei)
1399 : : {
1400 : 0 : ei->ktime = ktime_get_raw();
1401 : 0 : ei->render_c0 = intel_uncore_read(uncore, VLV_RENDER_C0_COUNT);
1402 : 0 : ei->media_c0 = intel_uncore_read(uncore, VLV_MEDIA_C0_COUNT);
1403 : 0 : }
1404 : :
1405 : 0 : static u32 vlv_wa_c0_ei(struct intel_rps *rps, u32 pm_iir)
1406 : : {
1407 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
1408 : 0 : const struct intel_rps_ei *prev = &rps->ei;
1409 : 0 : struct intel_rps_ei now;
1410 : 0 : u32 events = 0;
1411 : :
1412 [ # # ]: 0 : if ((pm_iir & GEN6_PM_RP_UP_EI_EXPIRED) == 0)
1413 : : return 0;
1414 : :
1415 : 0 : vlv_c0_read(uncore, &now);
1416 : :
1417 [ # # ]: 0 : if (prev->ktime) {
1418 : 0 : u64 time, c0;
1419 : 0 : u32 render, media;
1420 : :
1421 [ # # ]: 0 : time = ktime_us_delta(now.ktime, prev->ktime);
1422 : :
1423 : 0 : time *= rps_to_i915(rps)->czclk_freq;
1424 : :
1425 : : /* Workload can be split between render + media,
1426 : : * e.g. SwapBuffers being blitted in X after being rendered in
1427 : : * mesa. To account for this we need to combine both engines
1428 : : * into our activity counter.
1429 : : */
1430 : 0 : render = now.render_c0 - prev->render_c0;
1431 : 0 : media = now.media_c0 - prev->media_c0;
1432 : 0 : c0 = max(render, media);
1433 : 0 : c0 *= 1000 * 100 << 8; /* to usecs and scale to threshold% */
1434 : :
1435 [ # # ]: 0 : if (c0 > time * rps->power.up_threshold)
1436 : : events = GEN6_PM_RP_UP_THRESHOLD;
1437 [ # # ]: 0 : else if (c0 < time * rps->power.down_threshold)
1438 : 0 : events = GEN6_PM_RP_DOWN_THRESHOLD;
1439 : : }
1440 : :
1441 : 0 : rps->ei = now;
1442 : 0 : return events;
1443 : : }
1444 : :
1445 : 0 : static void rps_work(struct work_struct *work)
1446 : : {
1447 : 0 : struct intel_rps *rps = container_of(work, typeof(*rps), work);
1448 : 0 : struct intel_gt *gt = rps_to_gt(rps);
1449 : 0 : bool client_boost = false;
1450 : 0 : int new_freq, adj, min, max;
1451 : 0 : u32 pm_iir = 0;
1452 : :
1453 : 0 : spin_lock_irq(>->irq_lock);
1454 : 0 : pm_iir = fetch_and_zero(&rps->pm_iir);
1455 : 0 : client_boost = atomic_read(&rps->num_waiters);
1456 : 0 : spin_unlock_irq(>->irq_lock);
1457 : :
1458 : : /* Make sure we didn't queue anything we're not going to process. */
1459 [ # # # # ]: 0 : if ((pm_iir & rps->pm_events) == 0 && !client_boost)
1460 : 0 : goto out;
1461 : :
1462 : 0 : mutex_lock(&rps->lock);
1463 : :
1464 : 0 : pm_iir |= vlv_wa_c0_ei(rps, pm_iir);
1465 : :
1466 : 0 : adj = rps->last_adj;
1467 : 0 : new_freq = rps->cur_freq;
1468 : 0 : min = rps->min_freq_softlimit;
1469 : 0 : max = rps->max_freq_softlimit;
1470 [ # # ]: 0 : if (client_boost)
1471 : 0 : max = rps->max_freq;
1472 [ # # # # ]: 0 : if (client_boost && new_freq < rps->boost_freq) {
1473 : : new_freq = rps->boost_freq;
1474 : : adj = 0;
1475 [ # # ]: 0 : } else if (pm_iir & GEN6_PM_RP_UP_THRESHOLD) {
1476 [ # # ]: 0 : if (adj > 0)
1477 : 0 : adj *= 2;
1478 : : else /* CHV needs even encode values */
1479 [ # # ]: 0 : adj = IS_CHERRYVIEW(gt->i915) ? 2 : 1;
1480 : :
1481 [ # # ]: 0 : if (new_freq >= rps->max_freq_softlimit)
1482 : 0 : adj = 0;
1483 [ # # ]: 0 : } else if (client_boost) {
1484 : : adj = 0;
1485 [ # # ]: 0 : } else if (pm_iir & GEN6_PM_RP_DOWN_TIMEOUT) {
1486 [ # # ]: 0 : if (rps->cur_freq > rps->efficient_freq)
1487 : 0 : new_freq = rps->efficient_freq;
1488 [ # # ]: 0 : else if (rps->cur_freq > rps->min_freq_softlimit)
1489 : 0 : new_freq = rps->min_freq_softlimit;
1490 : : adj = 0;
1491 [ # # ]: 0 : } else if (pm_iir & GEN6_PM_RP_DOWN_THRESHOLD) {
1492 [ # # ]: 0 : if (adj < 0)
1493 : 0 : adj *= 2;
1494 : : else /* CHV needs even encode values */
1495 [ # # ]: 0 : adj = IS_CHERRYVIEW(gt->i915) ? -2 : -1;
1496 : :
1497 [ # # ]: 0 : if (new_freq <= rps->min_freq_softlimit)
1498 : 0 : adj = 0;
1499 : : } else { /* unknown event */
1500 : : adj = 0;
1501 : : }
1502 : :
1503 : 0 : rps->last_adj = adj;
1504 : :
1505 : : /*
1506 : : * Limit deboosting and boosting to keep ourselves at the extremes
1507 : : * when in the respective power modes (i.e. slowly decrease frequencies
1508 : : * while in the HIGH_POWER zone and slowly increase frequencies while
1509 : : * in the LOW_POWER zone). On idle, we will hit the timeout and drop
1510 : : * to the next level quickly, and conversely if busy we expect to
1511 : : * hit a waitboost and rapidly switch into max power.
1512 : : */
1513 [ # # # # : 0 : if ((adj < 0 && rps->power.mode == HIGH_POWER) ||
# # ]
1514 [ # # ]: 0 : (adj > 0 && rps->power.mode == LOW_POWER))
1515 : 0 : rps->last_adj = 0;
1516 : :
1517 : : /* sysfs frequency interfaces may have snuck in while servicing the
1518 : : * interrupt
1519 : : */
1520 : 0 : new_freq += adj;
1521 : 0 : new_freq = clamp_t(int, new_freq, min, max);
1522 : :
1523 [ # # ]: 0 : if (intel_rps_set(rps, new_freq)) {
1524 : 0 : DRM_DEBUG_DRIVER("Failed to set new GPU frequency\n");
1525 : 0 : rps->last_adj = 0;
1526 : : }
1527 : :
1528 : 0 : mutex_unlock(&rps->lock);
1529 : :
1530 : 0 : out:
1531 : 0 : spin_lock_irq(>->irq_lock);
1532 : 0 : gen6_gt_pm_unmask_irq(gt, rps->pm_events);
1533 : 0 : spin_unlock_irq(>->irq_lock);
1534 : 0 : }
1535 : :
1536 : 0 : void gen11_rps_irq_handler(struct intel_rps *rps, u32 pm_iir)
1537 : : {
1538 : 0 : struct intel_gt *gt = rps_to_gt(rps);
1539 : 0 : const u32 events = rps->pm_events & pm_iir;
1540 : :
1541 : 0 : lockdep_assert_held(>->irq_lock);
1542 : :
1543 [ # # ]: 0 : if (unlikely(!events))
1544 : : return;
1545 : :
1546 : 0 : gen6_gt_pm_mask_irq(gt, events);
1547 : :
1548 : 0 : rps->pm_iir |= events;
1549 : 0 : schedule_work(&rps->work);
1550 : : }
1551 : :
1552 : 0 : void gen6_rps_irq_handler(struct intel_rps *rps, u32 pm_iir)
1553 : : {
1554 : 0 : struct intel_gt *gt = rps_to_gt(rps);
1555 : :
1556 [ # # ]: 0 : if (pm_iir & rps->pm_events) {
1557 : 0 : spin_lock(>->irq_lock);
1558 : 0 : gen6_gt_pm_mask_irq(gt, pm_iir & rps->pm_events);
1559 : 0 : rps->pm_iir |= pm_iir & rps->pm_events;
1560 : 0 : schedule_work(&rps->work);
1561 : 0 : spin_unlock(>->irq_lock);
1562 : : }
1563 : :
1564 [ # # ]: 0 : if (INTEL_GEN(gt->i915) >= 8)
1565 : : return;
1566 : :
1567 [ # # ]: 0 : if (pm_iir & PM_VEBOX_USER_INTERRUPT)
1568 : 0 : intel_engine_signal_breadcrumbs(gt->engine[VECS0]);
1569 : :
1570 [ # # ]: 0 : if (pm_iir & PM_VEBOX_CS_ERROR_INTERRUPT)
1571 : 0 : DRM_DEBUG("Command parser error, pm_iir 0x%08x\n", pm_iir);
1572 : : }
1573 : :
1574 : 0 : void gen5_rps_irq_handler(struct intel_rps *rps)
1575 : : {
1576 : 0 : struct intel_uncore *uncore = rps_to_uncore(rps);
1577 : 0 : u32 busy_up, busy_down, max_avg, min_avg;
1578 : 0 : u8 new_freq;
1579 : :
1580 : 0 : spin_lock(&mchdev_lock);
1581 : :
1582 : 0 : intel_uncore_write16(uncore,
1583 : : MEMINTRSTS,
1584 : 0 : intel_uncore_read(uncore, MEMINTRSTS));
1585 : :
1586 : 0 : intel_uncore_write16(uncore, MEMINTRSTS, MEMINT_EVAL_CHG);
1587 : 0 : busy_up = intel_uncore_read(uncore, RCPREVBSYTUPAVG);
1588 : 0 : busy_down = intel_uncore_read(uncore, RCPREVBSYTDNAVG);
1589 : 0 : max_avg = intel_uncore_read(uncore, RCBMAXAVG);
1590 : 0 : min_avg = intel_uncore_read(uncore, RCBMINAVG);
1591 : :
1592 : : /* Handle RCS change request from hw */
1593 : 0 : new_freq = rps->cur_freq;
1594 [ # # ]: 0 : if (busy_up > max_avg)
1595 : 0 : new_freq++;
1596 [ # # ]: 0 : else if (busy_down < min_avg)
1597 : 0 : new_freq--;
1598 : 0 : new_freq = clamp(new_freq,
1599 : : rps->min_freq_softlimit,
1600 : : rps->max_freq_softlimit);
1601 : :
1602 [ # # # # ]: 0 : if (new_freq != rps->cur_freq && gen5_rps_set(rps, new_freq))
1603 : 0 : rps->cur_freq = new_freq;
1604 : :
1605 : 0 : spin_unlock(&mchdev_lock);
1606 : 0 : }
1607 : :
1608 : 0 : void intel_rps_init_early(struct intel_rps *rps)
1609 : : {
1610 : 0 : mutex_init(&rps->lock);
1611 : 0 : mutex_init(&rps->power.mutex);
1612 : :
1613 : 0 : INIT_WORK(&rps->work, rps_work);
1614 : :
1615 : 0 : atomic_set(&rps->num_waiters, 0);
1616 : 0 : }
1617 : :
1618 : 0 : void intel_rps_init(struct intel_rps *rps)
1619 : : {
1620 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1621 : :
1622 [ # # ]: 0 : if (IS_CHERRYVIEW(i915))
1623 : 0 : chv_rps_init(rps);
1624 [ # # ]: 0 : else if (IS_VALLEYVIEW(i915))
1625 : 0 : vlv_rps_init(rps);
1626 [ # # ]: 0 : else if (INTEL_GEN(i915) >= 6)
1627 : 0 : gen6_rps_init(rps);
1628 [ # # # # ]: 0 : else if (IS_IRONLAKE_M(i915))
1629 : 0 : gen5_rps_init(rps);
1630 : :
1631 : : /* Derive initial user preferences/limits from the hardware limits */
1632 : 0 : rps->max_freq_softlimit = rps->max_freq;
1633 : 0 : rps->min_freq_softlimit = rps->min_freq;
1634 : :
1635 : : /* After setting max-softlimit, find the overclock max freq */
1636 [ # # # # : 0 : if (IS_GEN(i915, 6) || IS_IVYBRIDGE(i915) || IS_HASWELL(i915)) {
# # ]
1637 : 0 : u32 params = 0;
1638 : :
1639 : 0 : sandybridge_pcode_read(i915, GEN6_READ_OC_PARAMS,
1640 : : ¶ms, NULL);
1641 [ # # ]: 0 : if (params & BIT(31)) { /* OC supported */
1642 : 0 : DRM_DEBUG_DRIVER("Overclocking supported, max: %dMHz, overclock: %dMHz\n",
1643 : : (rps->max_freq & 0xff) * 50,
1644 : : (params & 0xff) * 50);
1645 : 0 : rps->max_freq = params & 0xff;
1646 : : }
1647 : : }
1648 : :
1649 : : /* Finally allow us to boost to max by default */
1650 : 0 : rps->boost_freq = rps->max_freq;
1651 : 0 : rps->idle_freq = rps->min_freq;
1652 : 0 : rps->cur_freq = rps->idle_freq;
1653 : :
1654 : 0 : rps->pm_intrmsk_mbz = 0;
1655 : :
1656 : : /*
1657 : : * SNB,IVB,HSW can while VLV,CHV may hard hang on looping batchbuffer
1658 : : * if GEN6_PM_UP_EI_EXPIRED is masked.
1659 : : *
1660 : : * TODO: verify if this can be reproduced on VLV,CHV.
1661 : : */
1662 [ # # ]: 0 : if (INTEL_GEN(i915) <= 7)
1663 : 0 : rps->pm_intrmsk_mbz |= GEN6_PM_RP_UP_EI_EXPIRED;
1664 : :
1665 [ # # ]: 0 : if (INTEL_GEN(i915) >= 8 && INTEL_GEN(i915) < 11)
1666 : 0 : rps->pm_intrmsk_mbz |= GEN8_PMINTR_DISABLE_REDIRECT_TO_GUC;
1667 : 0 : }
1668 : :
1669 : 0 : u32 intel_rps_get_cagf(struct intel_rps *rps, u32 rpstat)
1670 : : {
1671 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1672 : 0 : u32 cagf;
1673 : :
1674 [ # # # # ]: 0 : if (IS_VALLEYVIEW(i915) || IS_CHERRYVIEW(i915))
1675 : 0 : cagf = (rpstat >> 8) & 0xff;
1676 [ # # ]: 0 : else if (INTEL_GEN(i915) >= 9)
1677 : 0 : cagf = (rpstat & GEN9_CAGF_MASK) >> GEN9_CAGF_SHIFT;
1678 [ # # # # ]: 0 : else if (IS_HASWELL(i915) || IS_BROADWELL(i915))
1679 : 0 : cagf = (rpstat & HSW_CAGF_MASK) >> HSW_CAGF_SHIFT;
1680 : : else
1681 : 0 : cagf = (rpstat & GEN6_CAGF_MASK) >> GEN6_CAGF_SHIFT;
1682 : :
1683 : 0 : return cagf;
1684 : : }
1685 : :
1686 : 0 : static u32 read_cagf(struct intel_rps *rps)
1687 : : {
1688 : 0 : struct drm_i915_private *i915 = rps_to_i915(rps);
1689 : 0 : u32 freq;
1690 : :
1691 [ # # # # ]: 0 : if (IS_VALLEYVIEW(i915) || IS_CHERRYVIEW(i915)) {
1692 : 0 : vlv_punit_get(i915);
1693 : 0 : freq = vlv_punit_read(i915, PUNIT_REG_GPU_FREQ_STS);
1694 : 0 : vlv_punit_put(i915);
1695 : : } else {
1696 : 0 : freq = intel_uncore_read(rps_to_gt(rps)->uncore, GEN6_RPSTAT1);
1697 : : }
1698 : :
1699 : 0 : return intel_rps_get_cagf(rps, freq);
1700 : : }
1701 : :
1702 : 0 : u32 intel_rps_read_actual_frequency(struct intel_rps *rps)
1703 : : {
1704 : 0 : struct intel_runtime_pm *rpm = rps_to_gt(rps)->uncore->rpm;
1705 : 0 : intel_wakeref_t wakeref;
1706 : 0 : u32 freq = 0;
1707 : :
1708 [ # # ]: 0 : with_intel_runtime_pm_if_in_use(rpm, wakeref)
1709 : 0 : freq = intel_gpu_freq(rps, read_cagf(rps));
1710 : :
1711 : 0 : return freq;
1712 : : }
1713 : :
1714 : : /* External interface for intel_ips.ko */
1715 : :
1716 : : static struct drm_i915_private __rcu *ips_mchdev;
1717 : :
1718 : : /**
1719 : : * Tells the intel_ips driver that the i915 driver is now loaded, if
1720 : : * IPS got loaded first.
1721 : : *
1722 : : * This awkward dance is so that neither module has to depend on the
1723 : : * other in order for IPS to do the appropriate communication of
1724 : : * GPU turbo limits to i915.
1725 : : */
1726 : : static void
1727 : 0 : ips_ping_for_i915_load(void)
1728 : : {
1729 : 0 : void (*link)(void);
1730 : :
1731 : 0 : link = symbol_get(ips_link_to_i915_driver);
1732 [ # # ]: 0 : if (link) {
1733 : 0 : link();
1734 : 0 : symbol_put(ips_link_to_i915_driver);
1735 : : }
1736 : 0 : }
1737 : :
1738 : 0 : void intel_rps_driver_register(struct intel_rps *rps)
1739 : : {
1740 : 0 : struct intel_gt *gt = rps_to_gt(rps);
1741 : :
1742 : : /*
1743 : : * We only register the i915 ips part with intel-ips once everything is
1744 : : * set up, to avoid intel-ips sneaking in and reading bogus values.
1745 : : */
1746 [ # # ]: 0 : if (IS_GEN(gt->i915, 5)) {
1747 : 0 : GEM_BUG_ON(ips_mchdev);
1748 : 0 : rcu_assign_pointer(ips_mchdev, gt->i915);
1749 : 0 : ips_ping_for_i915_load();
1750 : : }
1751 : 0 : }
1752 : :
1753 : 0 : void intel_rps_driver_unregister(struct intel_rps *rps)
1754 : : {
1755 [ # # ]: 0 : if (rcu_access_pointer(ips_mchdev) == rps_to_i915(rps))
1756 : 0 : rcu_assign_pointer(ips_mchdev, NULL);
1757 : 0 : }
1758 : :
1759 : 0 : static struct drm_i915_private *mchdev_get(void)
1760 : : {
1761 : 0 : struct drm_i915_private *i915;
1762 : :
1763 : 0 : rcu_read_lock();
1764 : 0 : i915 = rcu_dereference(ips_mchdev);
1765 [ # # # # : 0 : if (!kref_get_unless_zero(&i915->drm.ref))
# # # # #
# ]
1766 : 0 : i915 = NULL;
1767 : 0 : rcu_read_unlock();
1768 : :
1769 : 0 : return i915;
1770 : : }
1771 : :
1772 : : /**
1773 : : * i915_read_mch_val - return value for IPS use
1774 : : *
1775 : : * Calculate and return a value for the IPS driver to use when deciding whether
1776 : : * we have thermal and power headroom to increase CPU or GPU power budget.
1777 : : */
1778 : 0 : unsigned long i915_read_mch_val(void)
1779 : : {
1780 : 0 : struct drm_i915_private *i915;
1781 : 0 : unsigned long chipset_val = 0;
1782 : 0 : unsigned long graphics_val = 0;
1783 : 0 : intel_wakeref_t wakeref;
1784 : :
1785 : 0 : i915 = mchdev_get();
1786 [ # # ]: 0 : if (!i915)
1787 : 0 : return 0;
1788 : :
1789 [ # # ]: 0 : with_intel_runtime_pm(&i915->runtime_pm, wakeref) {
1790 : 0 : struct intel_ips *ips = &i915->gt.rps.ips;
1791 : :
1792 : 0 : spin_lock_irq(&mchdev_lock);
1793 : 0 : chipset_val = __ips_chipset_val(ips);
1794 : 0 : graphics_val = __ips_gfx_val(ips);
1795 : 0 : spin_unlock_irq(&mchdev_lock);
1796 : : }
1797 : :
1798 : 0 : drm_dev_put(&i915->drm);
1799 : 0 : return chipset_val + graphics_val;
1800 : : }
1801 : : EXPORT_SYMBOL_GPL(i915_read_mch_val);
1802 : :
1803 : : /**
1804 : : * i915_gpu_raise - raise GPU frequency limit
1805 : : *
1806 : : * Raise the limit; IPS indicates we have thermal headroom.
1807 : : */
1808 : 0 : bool i915_gpu_raise(void)
1809 : : {
1810 : 0 : struct drm_i915_private *i915;
1811 : 0 : struct intel_rps *rps;
1812 : :
1813 : 0 : i915 = mchdev_get();
1814 [ # # ]: 0 : if (!i915)
1815 : 0 : return false;
1816 : :
1817 : 0 : rps = &i915->gt.rps;
1818 : :
1819 : 0 : spin_lock_irq(&mchdev_lock);
1820 [ # # ]: 0 : if (rps->max_freq_softlimit < rps->max_freq)
1821 : 0 : rps->max_freq_softlimit++;
1822 : 0 : spin_unlock_irq(&mchdev_lock);
1823 : :
1824 : 0 : drm_dev_put(&i915->drm);
1825 : 0 : return true;
1826 : : }
1827 : : EXPORT_SYMBOL_GPL(i915_gpu_raise);
1828 : :
1829 : : /**
1830 : : * i915_gpu_lower - lower GPU frequency limit
1831 : : *
1832 : : * IPS indicates we're close to a thermal limit, so throttle back the GPU
1833 : : * frequency maximum.
1834 : : */
1835 : 0 : bool i915_gpu_lower(void)
1836 : : {
1837 : 0 : struct drm_i915_private *i915;
1838 : 0 : struct intel_rps *rps;
1839 : :
1840 : 0 : i915 = mchdev_get();
1841 [ # # ]: 0 : if (!i915)
1842 : 0 : return false;
1843 : :
1844 : 0 : rps = &i915->gt.rps;
1845 : :
1846 : 0 : spin_lock_irq(&mchdev_lock);
1847 [ # # ]: 0 : if (rps->max_freq_softlimit > rps->min_freq)
1848 : 0 : rps->max_freq_softlimit--;
1849 : 0 : spin_unlock_irq(&mchdev_lock);
1850 : :
1851 : 0 : drm_dev_put(&i915->drm);
1852 : 0 : return true;
1853 : : }
1854 : : EXPORT_SYMBOL_GPL(i915_gpu_lower);
1855 : :
1856 : : /**
1857 : : * i915_gpu_busy - indicate GPU business to IPS
1858 : : *
1859 : : * Tell the IPS driver whether or not the GPU is busy.
1860 : : */
1861 : 0 : bool i915_gpu_busy(void)
1862 : : {
1863 : 0 : struct drm_i915_private *i915;
1864 : 0 : bool ret;
1865 : :
1866 : 0 : i915 = mchdev_get();
1867 [ # # ]: 0 : if (!i915)
1868 : 0 : return false;
1869 : :
1870 : 0 : ret = i915->gt.awake;
1871 : :
1872 : 0 : drm_dev_put(&i915->drm);
1873 : 0 : return ret;
1874 : : }
1875 : : EXPORT_SYMBOL_GPL(i915_gpu_busy);
1876 : :
1877 : : /**
1878 : : * i915_gpu_turbo_disable - disable graphics turbo
1879 : : *
1880 : : * Disable graphics turbo by resetting the max frequency and setting the
1881 : : * current frequency to the default.
1882 : : */
1883 : 0 : bool i915_gpu_turbo_disable(void)
1884 : : {
1885 : 0 : struct drm_i915_private *i915;
1886 : 0 : struct intel_rps *rps;
1887 : 0 : bool ret;
1888 : :
1889 : 0 : i915 = mchdev_get();
1890 [ # # ]: 0 : if (!i915)
1891 : 0 : return false;
1892 : :
1893 : 0 : rps = &i915->gt.rps;
1894 : :
1895 : 0 : spin_lock_irq(&mchdev_lock);
1896 : 0 : rps->max_freq_softlimit = rps->min_freq;
1897 : 0 : ret = gen5_rps_set(&i915->gt.rps, rps->min_freq);
1898 : 0 : spin_unlock_irq(&mchdev_lock);
1899 : :
1900 : 0 : drm_dev_put(&i915->drm);
1901 : 0 : return ret;
1902 : : }
1903 : : EXPORT_SYMBOL_GPL(i915_gpu_turbo_disable);
|
