Rev 3746 | Rev 4126 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed
Rev 3746 | Rev 4104 | ||
---|---|---|---|
Line 35... | Line 35... | ||
35 | #define FORCEWAKE_ACK_TIMEOUT_MS 2 |
35 | #define FORCEWAKE_ACK_TIMEOUT_MS 2 |
Line 36... | Line 36... | ||
36 | 36 | ||
Line 37... | Line 37... | ||
37 | #define assert_spin_locked(x) |
37 | #define assert_spin_locked(x) |
38 | - | ||
Line 39... | Line -... | ||
39 | void getrawmonotonic(struct timespec *ts); |
- | |
40 | void set_normalized_timespec(struct timespec *ts, time_t sec, long nsec); |
- | |
41 | - | ||
42 | static inline struct timespec timespec_sub(struct timespec lhs, |
- | |
43 | struct timespec rhs) |
- | |
44 | { |
- | |
45 | struct timespec ts_delta; |
- | |
46 | set_normalized_timespec(&ts_delta, lhs.tv_sec - rhs.tv_sec, |
- | |
Line 47... | Line 38... | ||
47 | lhs.tv_nsec - rhs.tv_nsec); |
38 | |
48 | return ts_delta; |
39 | void getrawmonotonic(struct timespec *ts); |
49 | } |
40 | |
Line 100... | Line 91... | ||
100 | struct intel_crtc *intel_crtc = to_intel_crtc(crtc); |
91 | struct intel_crtc *intel_crtc = to_intel_crtc(crtc); |
101 | int cfb_pitch; |
92 | int cfb_pitch; |
102 | int plane, i; |
93 | int plane, i; |
103 | u32 fbc_ctl, fbc_ctl2; |
94 | u32 fbc_ctl, fbc_ctl2; |
Line 104... | Line 95... | ||
104 | 95 | ||
105 | cfb_pitch = dev_priv->cfb_size / FBC_LL_SIZE; |
96 | cfb_pitch = dev_priv->fbc.size / FBC_LL_SIZE; |
106 | if (fb->pitches[0] < cfb_pitch) |
97 | if (fb->pitches[0] < cfb_pitch) |
Line 107... | Line 98... | ||
107 | cfb_pitch = fb->pitches[0]; |
98 | cfb_pitch = fb->pitches[0]; |
108 | 99 | ||
Line 127... | Line 118... | ||
127 | fbc_ctl |= (cfb_pitch & 0xff) << FBC_CTL_STRIDE_SHIFT; |
118 | fbc_ctl |= (cfb_pitch & 0xff) << FBC_CTL_STRIDE_SHIFT; |
128 | fbc_ctl |= (interval & 0x2fff) << FBC_CTL_INTERVAL_SHIFT; |
119 | fbc_ctl |= (interval & 0x2fff) << FBC_CTL_INTERVAL_SHIFT; |
129 | fbc_ctl |= obj->fence_reg; |
120 | fbc_ctl |= obj->fence_reg; |
130 | I915_WRITE(FBC_CONTROL, fbc_ctl); |
121 | I915_WRITE(FBC_CONTROL, fbc_ctl); |
Line 131... | Line 122... | ||
131 | 122 | ||
132 | DRM_DEBUG_KMS("enabled FBC, pitch %d, yoff %d, plane %d, ", |
123 | DRM_DEBUG_KMS("enabled FBC, pitch %d, yoff %d, plane %c, ", |
133 | cfb_pitch, crtc->y, intel_crtc->plane); |
124 | cfb_pitch, crtc->y, plane_name(intel_crtc->plane)); |
Line 134... | Line 125... | ||
134 | } |
125 | } |
135 | 126 | ||
136 | static bool i8xx_fbc_enabled(struct drm_device *dev) |
127 | static bool i8xx_fbc_enabled(struct drm_device *dev) |
Line 162... | Line 153... | ||
162 | I915_WRITE(DPFC_FENCE_YOFF, crtc->y); |
153 | I915_WRITE(DPFC_FENCE_YOFF, crtc->y); |
Line 163... | Line 154... | ||
163 | 154 | ||
164 | /* enable it... */ |
155 | /* enable it... */ |
Line 165... | Line 156... | ||
165 | I915_WRITE(DPFC_CONTROL, I915_READ(DPFC_CONTROL) | DPFC_CTL_EN); |
156 | I915_WRITE(DPFC_CONTROL, I915_READ(DPFC_CONTROL) | DPFC_CTL_EN); |
166 | 157 | ||
Line 167... | Line 158... | ||
167 | DRM_DEBUG_KMS("enabled fbc on plane %d\n", intel_crtc->plane); |
158 | DRM_DEBUG_KMS("enabled fbc on plane %c\n", plane_name(intel_crtc->plane)); |
168 | } |
159 | } |
169 | 160 | ||
Line 231... | Line 222... | ||
231 | 222 | ||
232 | I915_WRITE(ILK_DPFC_RECOMP_CTL, DPFC_RECOMP_STALL_EN | |
223 | I915_WRITE(ILK_DPFC_RECOMP_CTL, DPFC_RECOMP_STALL_EN | |
233 | (stall_watermark << DPFC_RECOMP_STALL_WM_SHIFT) | |
224 | (stall_watermark << DPFC_RECOMP_STALL_WM_SHIFT) | |
234 | (interval << DPFC_RECOMP_TIMER_COUNT_SHIFT)); |
225 | (interval << DPFC_RECOMP_TIMER_COUNT_SHIFT)); |
235 | I915_WRITE(ILK_DPFC_FENCE_YOFF, crtc->y); |
226 | I915_WRITE(ILK_DPFC_FENCE_YOFF, crtc->y); |
236 | I915_WRITE(ILK_FBC_RT_BASE, obj->gtt_offset | ILK_FBC_RT_VALID); |
227 | I915_WRITE(ILK_FBC_RT_BASE, i915_gem_obj_ggtt_offset(obj) | ILK_FBC_RT_VALID); |
237 | /* enable it... */ |
228 | /* enable it... */ |
Line 238... | Line 229... | ||
238 | I915_WRITE(ILK_DPFC_CONTROL, dpfc_ctl | DPFC_CTL_EN); |
229 | I915_WRITE(ILK_DPFC_CONTROL, dpfc_ctl | DPFC_CTL_EN); |
239 | 230 | ||
240 | if (IS_GEN6(dev)) { |
231 | if (IS_GEN6(dev)) { |
241 | I915_WRITE(SNB_DPFC_CTL_SA, |
232 | I915_WRITE(SNB_DPFC_CTL_SA, |
242 | SNB_CPU_FENCE_ENABLE | obj->fence_reg); |
233 | SNB_CPU_FENCE_ENABLE | obj->fence_reg); |
243 | I915_WRITE(DPFC_CPU_FENCE_OFFSET, crtc->y); |
234 | I915_WRITE(DPFC_CPU_FENCE_OFFSET, crtc->y); |
Line 244... | Line 235... | ||
244 | sandybridge_blit_fbc_update(dev); |
235 | sandybridge_blit_fbc_update(dev); |
245 | } |
236 | } |
Line 246... | Line 237... | ||
246 | 237 | ||
247 | DRM_DEBUG_KMS("enabled fbc on plane %d\n", intel_crtc->plane); |
238 | DRM_DEBUG_KMS("enabled fbc on plane %c\n", plane_name(intel_crtc->plane)); |
248 | } |
239 | } |
Line 256... | Line 247... | ||
256 | dpfc_ctl = I915_READ(ILK_DPFC_CONTROL); |
247 | dpfc_ctl = I915_READ(ILK_DPFC_CONTROL); |
257 | if (dpfc_ctl & DPFC_CTL_EN) { |
248 | if (dpfc_ctl & DPFC_CTL_EN) { |
258 | dpfc_ctl &= ~DPFC_CTL_EN; |
249 | dpfc_ctl &= ~DPFC_CTL_EN; |
259 | I915_WRITE(ILK_DPFC_CONTROL, dpfc_ctl); |
250 | I915_WRITE(ILK_DPFC_CONTROL, dpfc_ctl); |
Line -... | Line 251... | ||
- | 251 | ||
- | 252 | if (IS_IVYBRIDGE(dev)) |
|
- | 253 | /* WaFbcDisableDpfcClockGating:ivb */ |
|
- | 254 | I915_WRITE(ILK_DSPCLK_GATE_D, |
|
- | 255 | I915_READ(ILK_DSPCLK_GATE_D) & |
|
- | 256 | ~ILK_DPFCUNIT_CLOCK_GATE_DISABLE); |
|
- | 257 | ||
- | 258 | if (IS_HASWELL(dev)) |
|
- | 259 | /* WaFbcDisableDpfcClockGating:hsw */ |
|
- | 260 | I915_WRITE(HSW_CLKGATE_DISABLE_PART_1, |
|
- | 261 | I915_READ(HSW_CLKGATE_DISABLE_PART_1) & |
|
- | 262 | ~HSW_DPFC_GATING_DISABLE); |
|
260 | 263 | ||
261 | DRM_DEBUG_KMS("disabled FBC\n"); |
264 | DRM_DEBUG_KMS("disabled FBC\n"); |
262 | } |
265 | } |
Line 263... | Line 266... | ||
263 | } |
266 | } |
Line 267... | Line 270... | ||
267 | struct drm_i915_private *dev_priv = dev->dev_private; |
270 | struct drm_i915_private *dev_priv = dev->dev_private; |
Line 268... | Line 271... | ||
268 | 271 | ||
269 | return I915_READ(ILK_DPFC_CONTROL) & DPFC_CTL_EN; |
272 | return I915_READ(ILK_DPFC_CONTROL) & DPFC_CTL_EN; |
Line -... | Line 273... | ||
- | 273 | } |
|
- | 274 | ||
- | 275 | static void gen7_enable_fbc(struct drm_crtc *crtc, unsigned long interval) |
|
- | 276 | { |
|
- | 277 | struct drm_device *dev = crtc->dev; |
|
- | 278 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 279 | struct drm_framebuffer *fb = crtc->fb; |
|
- | 280 | struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb); |
|
- | 281 | struct drm_i915_gem_object *obj = intel_fb->obj; |
|
- | 282 | struct intel_crtc *intel_crtc = to_intel_crtc(crtc); |
|
- | 283 | ||
- | 284 | I915_WRITE(IVB_FBC_RT_BASE, i915_gem_obj_ggtt_offset(obj)); |
|
- | 285 | ||
- | 286 | I915_WRITE(ILK_DPFC_CONTROL, DPFC_CTL_EN | DPFC_CTL_LIMIT_1X | |
|
- | 287 | IVB_DPFC_CTL_FENCE_EN | |
|
- | 288 | intel_crtc->plane << IVB_DPFC_CTL_PLANE_SHIFT); |
|
- | 289 | ||
- | 290 | if (IS_IVYBRIDGE(dev)) { |
|
- | 291 | /* WaFbcAsynchFlipDisableFbcQueue:ivb */ |
|
- | 292 | I915_WRITE(ILK_DISPLAY_CHICKEN1, ILK_FBCQ_DIS); |
|
- | 293 | /* WaFbcDisableDpfcClockGating:ivb */ |
|
- | 294 | I915_WRITE(ILK_DSPCLK_GATE_D, |
|
- | 295 | I915_READ(ILK_DSPCLK_GATE_D) | |
|
- | 296 | ILK_DPFCUNIT_CLOCK_GATE_DISABLE); |
|
- | 297 | } else { |
|
- | 298 | /* WaFbcAsynchFlipDisableFbcQueue:hsw */ |
|
- | 299 | I915_WRITE(HSW_PIPE_SLICE_CHICKEN_1(intel_crtc->pipe), |
|
- | 300 | HSW_BYPASS_FBC_QUEUE); |
|
- | 301 | /* WaFbcDisableDpfcClockGating:hsw */ |
|
- | 302 | I915_WRITE(HSW_CLKGATE_DISABLE_PART_1, |
|
- | 303 | I915_READ(HSW_CLKGATE_DISABLE_PART_1) | |
|
- | 304 | HSW_DPFC_GATING_DISABLE); |
|
- | 305 | } |
|
- | 306 | ||
- | 307 | I915_WRITE(SNB_DPFC_CTL_SA, |
|
- | 308 | SNB_CPU_FENCE_ENABLE | obj->fence_reg); |
|
- | 309 | I915_WRITE(DPFC_CPU_FENCE_OFFSET, crtc->y); |
|
- | 310 | ||
- | 311 | sandybridge_blit_fbc_update(dev); |
|
- | 312 | ||
- | 313 | DRM_DEBUG_KMS("enabled fbc on plane %d\n", intel_crtc->plane); |
|
270 | } |
314 | } |
271 | 315 | ||
272 | bool intel_fbc_enabled(struct drm_device *dev) |
316 | bool intel_fbc_enabled(struct drm_device *dev) |
Line 273... | Line 317... | ||
273 | { |
317 | { |
Line 286... | Line 330... | ||
286 | struct intel_fbc_work, work); |
330 | struct intel_fbc_work, work); |
287 | struct drm_device *dev = work->crtc->dev; |
331 | struct drm_device *dev = work->crtc->dev; |
288 | struct drm_i915_private *dev_priv = dev->dev_private; |
332 | struct drm_i915_private *dev_priv = dev->dev_private; |
Line 289... | Line 333... | ||
289 | 333 | ||
290 | mutex_lock(&dev->struct_mutex); |
334 | mutex_lock(&dev->struct_mutex); |
291 | if (work == dev_priv->fbc_work) { |
335 | if (work == dev_priv->fbc.fbc_work) { |
292 | /* Double check that we haven't switched fb without cancelling |
336 | /* Double check that we haven't switched fb without cancelling |
293 | * the prior work. |
337 | * the prior work. |
294 | */ |
338 | */ |
295 | if (work->crtc->fb == work->fb) { |
339 | if (work->crtc->fb == work->fb) { |
296 | dev_priv->display.enable_fbc(work->crtc, |
340 | dev_priv->display.enable_fbc(work->crtc, |
Line 297... | Line 341... | ||
297 | work->interval); |
341 | work->interval); |
298 | 342 | ||
299 | dev_priv->cfb_plane = to_intel_crtc(work->crtc)->plane; |
343 | dev_priv->fbc.plane = to_intel_crtc(work->crtc)->plane; |
300 | dev_priv->cfb_fb = work->crtc->fb->base.id; |
344 | dev_priv->fbc.fb_id = work->crtc->fb->base.id; |
Line 301... | Line 345... | ||
301 | dev_priv->cfb_y = work->crtc->y; |
345 | dev_priv->fbc.y = work->crtc->y; |
302 | } |
346 | } |
303 | 347 | ||
Line 304... | Line 348... | ||
304 | dev_priv->fbc_work = NULL; |
348 | dev_priv->fbc.fbc_work = NULL; |
305 | } |
349 | } |
Line 306... | Line 350... | ||
306 | mutex_unlock(&dev->struct_mutex); |
350 | mutex_unlock(&dev->struct_mutex); |
307 | 351 | ||
308 | kfree(work); |
352 | kfree(work); |
309 | } |
353 | } |
Line 310... | Line 354... | ||
310 | 354 | ||
Line 311... | Line 355... | ||
311 | static void intel_cancel_fbc_work(struct drm_i915_private *dev_priv) |
355 | static void intel_cancel_fbc_work(struct drm_i915_private *dev_priv) |
312 | { |
356 | { |
313 | if (dev_priv->fbc_work == NULL) |
357 | if (dev_priv->fbc.fbc_work == NULL) |
314 | return; |
358 | return; |
315 | 359 | ||
316 | DRM_DEBUG_KMS("cancelling pending FBC enable\n"); |
360 | DRM_DEBUG_KMS("cancelling pending FBC enable\n"); |
317 | 361 | ||
Line 326... | Line 370... | ||
326 | /* Mark the work as no longer wanted so that if it does |
370 | /* Mark the work as no longer wanted so that if it does |
327 | * wake-up (because the work was already running and waiting |
371 | * wake-up (because the work was already running and waiting |
328 | * for our mutex), it will discover that is no longer |
372 | * for our mutex), it will discover that is no longer |
329 | * necessary to run. |
373 | * necessary to run. |
330 | */ |
374 | */ |
331 | dev_priv->fbc_work = NULL; |
375 | dev_priv->fbc.fbc_work = NULL; |
332 | } |
376 | } |
Line 333... | Line 377... | ||
333 | 377 | ||
334 | void intel_enable_fbc(struct drm_crtc *crtc, unsigned long interval) |
378 | static void intel_enable_fbc(struct drm_crtc *crtc, unsigned long interval) |
335 | { |
379 | { |
336 | struct intel_fbc_work *work; |
380 | struct intel_fbc_work *work; |
337 | struct drm_device *dev = crtc->dev; |
381 | struct drm_device *dev = crtc->dev; |
Line 342... | Line 386... | ||
342 | 386 | ||
Line 343... | Line 387... | ||
343 | intel_cancel_fbc_work(dev_priv); |
387 | intel_cancel_fbc_work(dev_priv); |
344 | 388 | ||
- | 389 | work = kzalloc(sizeof *work, GFP_KERNEL); |
|
345 | work = kzalloc(sizeof *work, GFP_KERNEL); |
390 | if (work == NULL) { |
346 | if (work == NULL) { |
391 | DRM_ERROR("Failed to allocate FBC work structure\n"); |
347 | dev_priv->display.enable_fbc(crtc, interval); |
392 | dev_priv->display.enable_fbc(crtc, interval); |
Line 348... | Line 393... | ||
348 | return; |
393 | return; |
349 | } |
394 | } |
350 | 395 | ||
351 | work->crtc = crtc; |
396 | work->crtc = crtc; |
Line 352... | Line 397... | ||
352 | work->fb = crtc->fb; |
397 | work->fb = crtc->fb; |
Line 353... | Line 398... | ||
353 | work->interval = interval; |
398 | work->interval = interval; |
Line 354... | Line 399... | ||
354 | INIT_DELAYED_WORK(&work->work, intel_fbc_work_fn); |
399 | INIT_DELAYED_WORK(&work->work, intel_fbc_work_fn); |
355 | 400 | ||
Line 365... | Line 410... | ||
365 | * |
410 | * |
366 | * A more complicated solution would involve tracking vblanks |
411 | * A more complicated solution would involve tracking vblanks |
367 | * following the termination of the page-flipping sequence |
412 | * following the termination of the page-flipping sequence |
368 | * and indeed performing the enable as a co-routine and not |
413 | * and indeed performing the enable as a co-routine and not |
369 | * waiting synchronously upon the vblank. |
414 | * waiting synchronously upon the vblank. |
- | 415 | * |
|
- | 416 | * WaFbcWaitForVBlankBeforeEnable:ilk,snb |
|
370 | */ |
417 | */ |
371 | schedule_delayed_work(&work->work, msecs_to_jiffies(50)); |
418 | schedule_delayed_work(&work->work, msecs_to_jiffies(50)); |
372 | } |
419 | } |
Line 373... | Line 420... | ||
373 | 420 | ||
Line 379... | Line 426... | ||
379 | 426 | ||
380 | if (!dev_priv->display.disable_fbc) |
427 | if (!dev_priv->display.disable_fbc) |
Line 381... | Line 428... | ||
381 | return; |
428 | return; |
382 | 429 | ||
- | 430 | dev_priv->display.disable_fbc(dev); |
|
- | 431 | dev_priv->fbc.plane = -1; |
|
- | 432 | } |
|
- | 433 | ||
- | 434 | static bool set_no_fbc_reason(struct drm_i915_private *dev_priv, |
|
- | 435 | enum no_fbc_reason reason) |
|
- | 436 | { |
|
- | 437 | if (dev_priv->fbc.no_fbc_reason == reason) |
|
- | 438 | return false; |
|
- | 439 | ||
383 | dev_priv->display.disable_fbc(dev); |
440 | dev_priv->fbc.no_fbc_reason = reason; |
Line 384... | Line 441... | ||
384 | dev_priv->cfb_plane = -1; |
441 | return true; |
385 | } |
442 | } |
386 | 443 | ||
Line 392... | Line 449... | ||
392 | * enable it if possible: |
449 | * enable it if possible: |
393 | * - plane A only (on pre-965) |
450 | * - plane A only (on pre-965) |
394 | * - no pixel mulitply/line duplication |
451 | * - no pixel mulitply/line duplication |
395 | * - no alpha buffer discard |
452 | * - no alpha buffer discard |
396 | * - no dual wide |
453 | * - no dual wide |
397 | * - framebuffer <= 2048 in width, 1536 in height |
454 | * - framebuffer <= max_hdisplay in width, max_vdisplay in height |
398 | * |
455 | * |
399 | * We can't assume that any compression will take place (worst case), |
456 | * We can't assume that any compression will take place (worst case), |
400 | * so the compressed buffer has to be the same size as the uncompressed |
457 | * so the compressed buffer has to be the same size as the uncompressed |
401 | * one. It also must reside (along with the line length buffer) in |
458 | * one. It also must reside (along with the line length buffer) in |
402 | * stolen memory. |
459 | * stolen memory. |
Line 409... | Line 466... | ||
409 | struct drm_crtc *crtc = NULL, *tmp_crtc; |
466 | struct drm_crtc *crtc = NULL, *tmp_crtc; |
410 | struct intel_crtc *intel_crtc; |
467 | struct intel_crtc *intel_crtc; |
411 | struct drm_framebuffer *fb; |
468 | struct drm_framebuffer *fb; |
412 | struct intel_framebuffer *intel_fb; |
469 | struct intel_framebuffer *intel_fb; |
413 | struct drm_i915_gem_object *obj; |
470 | struct drm_i915_gem_object *obj; |
414 | int enable_fbc; |
471 | unsigned int max_hdisplay, max_vdisplay; |
Line 415... | Line -... | ||
415 | - | ||
416 | ENTER(); |
- | |
417 | 472 | ||
- | 473 | if (!I915_HAS_FBC(dev)) { |
|
418 | if (!i915_powersave) |
474 | set_no_fbc_reason(dev_priv, FBC_UNSUPPORTED); |
- | 475 | return; |
|
Line 419... | Line 476... | ||
419 | return; |
476 | } |
- | 477 | ||
- | 478 | if (!i915_powersave) { |
|
420 | 479 | if (set_no_fbc_reason(dev_priv, FBC_MODULE_PARAM)) |
|
- | 480 | DRM_DEBUG_KMS("fbc disabled per module param\n"); |
|
Line 421... | Line 481... | ||
421 | if (!I915_HAS_FBC(dev)) |
481 | return; |
422 | return; |
482 | } |
423 | 483 | ||
424 | /* |
484 | /* |
Line 432... | Line 492... | ||
432 | */ |
492 | */ |
433 | list_for_each_entry(tmp_crtc, &dev->mode_config.crtc_list, head) { |
493 | list_for_each_entry(tmp_crtc, &dev->mode_config.crtc_list, head) { |
434 | if (intel_crtc_active(tmp_crtc) && |
494 | if (intel_crtc_active(tmp_crtc) && |
435 | !to_intel_crtc(tmp_crtc)->primary_disabled) { |
495 | !to_intel_crtc(tmp_crtc)->primary_disabled) { |
436 | if (crtc) { |
496 | if (crtc) { |
- | 497 | if (set_no_fbc_reason(dev_priv, FBC_MULTIPLE_PIPES)) |
|
437 | DRM_DEBUG_KMS("more than one pipe active, disabling compression\n"); |
498 | DRM_DEBUG_KMS("more than one pipe active, disabling compression\n"); |
438 | dev_priv->no_fbc_reason = FBC_MULTIPLE_PIPES; |
- | |
439 | goto out_disable; |
499 | goto out_disable; |
440 | } |
500 | } |
441 | crtc = tmp_crtc; |
501 | crtc = tmp_crtc; |
442 | } |
502 | } |
443 | } |
503 | } |
Line 444... | Line 504... | ||
444 | 504 | ||
- | 505 | if (!crtc || crtc->fb == NULL) { |
|
445 | if (!crtc || crtc->fb == NULL) { |
506 | if (set_no_fbc_reason(dev_priv, FBC_NO_OUTPUT)) |
446 | DRM_DEBUG_KMS("no output, disabling\n"); |
- | |
447 | dev_priv->no_fbc_reason = FBC_NO_OUTPUT; |
507 | DRM_DEBUG_KMS("no output, disabling\n"); |
448 | goto out_disable; |
508 | goto out_disable; |
Line 449... | Line 509... | ||
449 | } |
509 | } |
450 | 510 | ||
451 | intel_crtc = to_intel_crtc(crtc); |
511 | intel_crtc = to_intel_crtc(crtc); |
452 | fb = crtc->fb; |
512 | fb = crtc->fb; |
Line 453... | Line -... | ||
453 | intel_fb = to_intel_framebuffer(fb); |
- | |
454 | obj = intel_fb->obj; |
513 | intel_fb = to_intel_framebuffer(fb); |
455 | 514 | obj = intel_fb->obj; |
|
456 | enable_fbc = i915_enable_fbc; |
515 | |
457 | if (enable_fbc < 0) { |
516 | if (i915_enable_fbc < 0 && |
458 | DRM_DEBUG_KMS("fbc set to per-chip default\n"); |
517 | INTEL_INFO(dev)->gen <= 7 && !IS_HASWELL(dev)) { |
459 | enable_fbc = 1; |
518 | if (set_no_fbc_reason(dev_priv, FBC_CHIP_DEFAULT)) |
460 | if (INTEL_INFO(dev)->gen <= 6) |
519 | DRM_DEBUG_KMS("disabled per chip default\n"); |
- | 520 | goto out_disable; |
|
461 | enable_fbc = 0; |
521 | } |
462 | } |
- | |
463 | if (!enable_fbc) { |
522 | if (!i915_enable_fbc) { |
464 | DRM_DEBUG_KMS("fbc disabled per module param\n"); |
523 | if (set_no_fbc_reason(dev_priv, FBC_MODULE_PARAM)) |
465 | dev_priv->no_fbc_reason = FBC_MODULE_PARAM; |
524 | DRM_DEBUG_KMS("fbc disabled per module param\n"); |
466 | goto out_disable; |
525 | goto out_disable; |
- | 526 | } |
|
467 | } |
527 | if ((crtc->mode.flags & DRM_MODE_FLAG_INTERLACE) || |
468 | if ((crtc->mode.flags & DRM_MODE_FLAG_INTERLACE) || |
528 | (crtc->mode.flags & DRM_MODE_FLAG_DBLSCAN)) { |
469 | (crtc->mode.flags & DRM_MODE_FLAG_DBLSCAN)) { |
- | |
470 | DRM_DEBUG_KMS("mode incompatible with compression, " |
529 | if (set_no_fbc_reason(dev_priv, FBC_UNSUPPORTED_MODE)) |
471 | "disabling\n"); |
530 | DRM_DEBUG_KMS("mode incompatible with compression, " |
- | 531 | "disabling\n"); |
|
- | 532 | goto out_disable; |
|
- | 533 | } |
|
- | 534 | ||
- | 535 | if (IS_G4X(dev) || INTEL_INFO(dev)->gen >= 5) { |
|
- | 536 | max_hdisplay = 4096; |
|
- | 537 | max_vdisplay = 2048; |
|
- | 538 | } else { |
|
472 | dev_priv->no_fbc_reason = FBC_UNSUPPORTED_MODE; |
539 | max_hdisplay = 2048; |
473 | goto out_disable; |
540 | max_vdisplay = 1536; |
- | 541 | } |
|
474 | } |
542 | if ((crtc->mode.hdisplay > max_hdisplay) || |
475 | if ((crtc->mode.hdisplay > 2048) || |
- | |
476 | (crtc->mode.vdisplay > 1536)) { |
543 | (crtc->mode.vdisplay > max_vdisplay)) { |
477 | DRM_DEBUG_KMS("mode too large for compression, disabling\n"); |
544 | if (set_no_fbc_reason(dev_priv, FBC_MODE_TOO_LARGE)) |
478 | dev_priv->no_fbc_reason = FBC_MODE_TOO_LARGE; |
545 | DRM_DEBUG_KMS("mode too large for compression, disabling\n"); |
- | 546 | goto out_disable; |
|
- | 547 | } |
|
479 | goto out_disable; |
548 | if ((IS_I915GM(dev) || IS_I945GM(dev) || IS_HASWELL(dev)) && |
480 | } |
- | |
481 | if ((IS_I915GM(dev) || IS_I945GM(dev)) && intel_crtc->plane != 0) { |
549 | intel_crtc->plane != 0) { |
482 | DRM_DEBUG_KMS("plane not 0, disabling compression\n"); |
550 | if (set_no_fbc_reason(dev_priv, FBC_BAD_PLANE)) |
Line 483... | Line 551... | ||
483 | dev_priv->no_fbc_reason = FBC_BAD_PLANE; |
551 | DRM_DEBUG_KMS("plane not 0, disabling compression\n"); |
484 | goto out_disable; |
552 | goto out_disable; |
485 | } |
553 | } |
486 | 554 | ||
487 | /* The use of a CPU fence is mandatory in order to detect writes |
555 | /* The use of a CPU fence is mandatory in order to detect writes |
- | 556 | * by the CPU to the scanout and trigger updates to the FBC. |
|
488 | * by the CPU to the scanout and trigger updates to the FBC. |
557 | */ |
489 | */ |
- | |
490 | if (obj->tiling_mode != I915_TILING_X || |
558 | if (obj->tiling_mode != I915_TILING_X || |
491 | obj->fence_reg == I915_FENCE_REG_NONE) { |
559 | obj->fence_reg == I915_FENCE_REG_NONE) { |
Line 492... | Line 560... | ||
492 | DRM_DEBUG_KMS("framebuffer not tiled or fenced, disabling compression\n"); |
560 | if (set_no_fbc_reason(dev_priv, FBC_NOT_TILED)) |
493 | dev_priv->no_fbc_reason = FBC_NOT_TILED; |
561 | DRM_DEBUG_KMS("framebuffer not tiled or fenced, disabling compression\n"); |
494 | goto out_disable; |
562 | goto out_disable; |
Line 495... | Line 563... | ||
495 | } |
563 | } |
496 | - | ||
497 | /* If the kernel debugger is active, always disable compression */ |
564 | |
498 | if (in_dbg_master()) |
565 | /* If the kernel debugger is active, always disable compression */ |
499 | goto out_disable; |
- | |
500 | 566 | if (in_dbg_master()) |
|
501 | if (i915_gem_stolen_setup_compression(dev, intel_fb->obj->base.size)) { |
567 | goto out_disable; |
Line 502... | Line 568... | ||
502 | DRM_INFO("not enough stolen space for compressed buffer (need %zd bytes), disabling\n", intel_fb->obj->base.size); |
568 | |
503 | DRM_INFO("hint: you may be able to increase stolen memory size in the BIOS to avoid this\n"); |
569 | if (i915_gem_stolen_setup_compression(dev, intel_fb->obj->base.size)) { |
504 | DRM_DEBUG_KMS("framebuffer too large, disabling compression\n"); |
570 | if (set_no_fbc_reason(dev_priv, FBC_STOLEN_TOO_SMALL)) |
505 | dev_priv->no_fbc_reason = FBC_STOLEN_TOO_SMALL; |
571 | DRM_DEBUG_KMS("framebuffer too large, disabling compression\n"); |
506 | goto out_disable; |
572 | goto out_disable; |
507 | } |
573 | } |
508 | 574 | ||
509 | /* If the scanout has not changed, don't modify the FBC settings. |
575 | /* If the scanout has not changed, don't modify the FBC settings. |
510 | * Note that we make the fundamental assumption that the fb->obj |
576 | * Note that we make the fundamental assumption that the fb->obj |
Line 511... | Line 577... | ||
511 | * cannot be unpinned (and have its GTT offset and fence revoked) |
577 | * cannot be unpinned (and have its GTT offset and fence revoked) |
512 | * without first being decoupled from the scanout and FBC disabled. |
578 | * without first being decoupled from the scanout and FBC disabled. |
513 | */ |
579 | */ |
Line 543... | Line 609... | ||
543 | DRM_DEBUG_KMS("disabling active FBC for update\n"); |
609 | DRM_DEBUG_KMS("disabling active FBC for update\n"); |
544 | intel_disable_fbc(dev); |
610 | intel_disable_fbc(dev); |
545 | } |
611 | } |
Line 546... | Line 612... | ||
546 | 612 | ||
547 | intel_enable_fbc(crtc, 500); |
613 | intel_enable_fbc(crtc, 500); |
548 | LEAVE(); |
- | |
549 | 614 | dev_priv->fbc.no_fbc_reason = FBC_OK; |
|
Line 550... | Line 615... | ||
550 | return; |
615 | return; |
551 | 616 | ||
552 | out_disable: |
617 | out_disable: |
553 | /* Multiple disables should be harmless */ |
618 | /* Multiple disables should be harmless */ |
554 | if (intel_fbc_enabled(dev)) { |
619 | if (intel_fbc_enabled(dev)) { |
555 | DRM_DEBUG_KMS("unsupported config, disabling FBC\n"); |
620 | DRM_DEBUG_KMS("unsupported config, disabling FBC\n"); |
556 | intel_disable_fbc(dev); |
621 | intel_disable_fbc(dev); |
557 | } |
- | |
558 | i915_gem_stolen_cleanup_compression(dev); |
622 | } |
Line 559... | Line 623... | ||
559 | LEAVE(); |
623 | i915_gem_stolen_cleanup_compression(dev); |
560 | } |
624 | } |
561 | 625 | ||
Line 1624... | Line 1688... | ||
1624 | DRM_DEBUG_KMS("Setting FIFO watermarks - A: %d\n", planea_wm); |
1688 | DRM_DEBUG_KMS("Setting FIFO watermarks - A: %d\n", planea_wm); |
Line 1625... | Line 1689... | ||
1625 | 1689 | ||
1626 | I915_WRITE(FW_BLC, fwater_lo); |
1690 | I915_WRITE(FW_BLC, fwater_lo); |
Line 1627... | Line -... | ||
1627 | } |
- | |
1628 | - | ||
1629 | #define ILK_LP0_PLANE_LATENCY 700 |
- | |
1630 | #define ILK_LP0_CURSOR_LATENCY 1300 |
1691 | } |
1631 | 1692 | ||
1632 | /* |
1693 | /* |
1633 | * Check the wm result. |
1694 | * Check the wm result. |
1634 | * |
1695 | * |
Line 1652... | Line 1713... | ||
1652 | 1713 | ||
1653 | /* fbc has it's own way to disable FBC WM */ |
1714 | /* fbc has it's own way to disable FBC WM */ |
1654 | I915_WRITE(DISP_ARB_CTL, |
1715 | I915_WRITE(DISP_ARB_CTL, |
1655 | I915_READ(DISP_ARB_CTL) | DISP_FBC_WM_DIS); |
1716 | I915_READ(DISP_ARB_CTL) | DISP_FBC_WM_DIS); |
- | 1717 | return false; |
|
- | 1718 | } else if (INTEL_INFO(dev)->gen >= 6) { |
|
- | 1719 | /* enable FBC WM (except on ILK, where it must remain off) */ |
|
- | 1720 | I915_WRITE(DISP_ARB_CTL, |
|
1656 | return false; |
1721 | I915_READ(DISP_ARB_CTL) & ~DISP_FBC_WM_DIS); |
Line 1657... | Line 1722... | ||
1657 | } |
1722 | } |
1658 | 1723 | ||
1659 | if (display_wm > display->max_wm) { |
1724 | if (display_wm > display->max_wm) { |
Line 1737... | Line 1802... | ||
1737 | unsigned int enabled; |
1802 | unsigned int enabled; |
Line 1738... | Line 1803... | ||
1738 | 1803 | ||
1739 | enabled = 0; |
1804 | enabled = 0; |
1740 | if (g4x_compute_wm0(dev, PIPE_A, |
1805 | if (g4x_compute_wm0(dev, PIPE_A, |
1741 | &ironlake_display_wm_info, |
1806 | &ironlake_display_wm_info, |
1742 | ILK_LP0_PLANE_LATENCY, |
1807 | dev_priv->wm.pri_latency[0] * 100, |
1743 | &ironlake_cursor_wm_info, |
1808 | &ironlake_cursor_wm_info, |
1744 | ILK_LP0_CURSOR_LATENCY, |
1809 | dev_priv->wm.cur_latency[0] * 100, |
1745 | &plane_wm, &cursor_wm)) { |
1810 | &plane_wm, &cursor_wm)) { |
1746 | I915_WRITE(WM0_PIPEA_ILK, |
1811 | I915_WRITE(WM0_PIPEA_ILK, |
1747 | (plane_wm << WM0_PIPE_PLANE_SHIFT) | cursor_wm); |
1812 | (plane_wm << WM0_PIPE_PLANE_SHIFT) | cursor_wm); |
1748 | DRM_DEBUG_KMS("FIFO watermarks For pipe A -" |
1813 | DRM_DEBUG_KMS("FIFO watermarks For pipe A -" |
Line 1751... | Line 1816... | ||
1751 | enabled |= 1 << PIPE_A; |
1816 | enabled |= 1 << PIPE_A; |
1752 | } |
1817 | } |
Line 1753... | Line 1818... | ||
1753 | 1818 | ||
1754 | if (g4x_compute_wm0(dev, PIPE_B, |
1819 | if (g4x_compute_wm0(dev, PIPE_B, |
1755 | &ironlake_display_wm_info, |
1820 | &ironlake_display_wm_info, |
1756 | ILK_LP0_PLANE_LATENCY, |
1821 | dev_priv->wm.pri_latency[0] * 100, |
1757 | &ironlake_cursor_wm_info, |
1822 | &ironlake_cursor_wm_info, |
1758 | ILK_LP0_CURSOR_LATENCY, |
1823 | dev_priv->wm.cur_latency[0] * 100, |
1759 | &plane_wm, &cursor_wm)) { |
1824 | &plane_wm, &cursor_wm)) { |
1760 | I915_WRITE(WM0_PIPEB_ILK, |
1825 | I915_WRITE(WM0_PIPEB_ILK, |
1761 | (plane_wm << WM0_PIPE_PLANE_SHIFT) | cursor_wm); |
1826 | (plane_wm << WM0_PIPE_PLANE_SHIFT) | cursor_wm); |
1762 | DRM_DEBUG_KMS("FIFO watermarks For pipe B -" |
1827 | DRM_DEBUG_KMS("FIFO watermarks For pipe B -" |
Line 1777... | Line 1842... | ||
1777 | return; |
1842 | return; |
1778 | enabled = ffs(enabled) - 1; |
1843 | enabled = ffs(enabled) - 1; |
Line 1779... | Line 1844... | ||
1779 | 1844 | ||
1780 | /* WM1 */ |
1845 | /* WM1 */ |
1781 | if (!ironlake_compute_srwm(dev, 1, enabled, |
1846 | if (!ironlake_compute_srwm(dev, 1, enabled, |
1782 | ILK_READ_WM1_LATENCY() * 500, |
1847 | dev_priv->wm.pri_latency[1] * 500, |
1783 | &ironlake_display_srwm_info, |
1848 | &ironlake_display_srwm_info, |
1784 | &ironlake_cursor_srwm_info, |
1849 | &ironlake_cursor_srwm_info, |
1785 | &fbc_wm, &plane_wm, &cursor_wm)) |
1850 | &fbc_wm, &plane_wm, &cursor_wm)) |
Line 1786... | Line 1851... | ||
1786 | return; |
1851 | return; |
1787 | 1852 | ||
1788 | I915_WRITE(WM1_LP_ILK, |
1853 | I915_WRITE(WM1_LP_ILK, |
1789 | WM1_LP_SR_EN | |
1854 | WM1_LP_SR_EN | |
1790 | (ILK_READ_WM1_LATENCY() << WM1_LP_LATENCY_SHIFT) | |
1855 | (dev_priv->wm.pri_latency[1] << WM1_LP_LATENCY_SHIFT) | |
1791 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
1856 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
Line 1792... | Line 1857... | ||
1792 | (plane_wm << WM1_LP_SR_SHIFT) | |
1857 | (plane_wm << WM1_LP_SR_SHIFT) | |
1793 | cursor_wm); |
1858 | cursor_wm); |
1794 | 1859 | ||
1795 | /* WM2 */ |
1860 | /* WM2 */ |
1796 | if (!ironlake_compute_srwm(dev, 2, enabled, |
1861 | if (!ironlake_compute_srwm(dev, 2, enabled, |
1797 | ILK_READ_WM2_LATENCY() * 500, |
1862 | dev_priv->wm.pri_latency[2] * 500, |
1798 | &ironlake_display_srwm_info, |
1863 | &ironlake_display_srwm_info, |
Line 1799... | Line 1864... | ||
1799 | &ironlake_cursor_srwm_info, |
1864 | &ironlake_cursor_srwm_info, |
1800 | &fbc_wm, &plane_wm, &cursor_wm)) |
1865 | &fbc_wm, &plane_wm, &cursor_wm)) |
1801 | return; |
1866 | return; |
1802 | 1867 | ||
1803 | I915_WRITE(WM2_LP_ILK, |
1868 | I915_WRITE(WM2_LP_ILK, |
1804 | WM2_LP_EN | |
1869 | WM2_LP_EN | |
Line 1805... | Line 1870... | ||
1805 | (ILK_READ_WM2_LATENCY() << WM1_LP_LATENCY_SHIFT) | |
1870 | (dev_priv->wm.pri_latency[2] << WM1_LP_LATENCY_SHIFT) | |
Line 1814... | Line 1879... | ||
1814 | } |
1879 | } |
Line 1815... | Line 1880... | ||
1815 | 1880 | ||
1816 | static void sandybridge_update_wm(struct drm_device *dev) |
1881 | static void sandybridge_update_wm(struct drm_device *dev) |
1817 | { |
1882 | { |
1818 | struct drm_i915_private *dev_priv = dev->dev_private; |
1883 | struct drm_i915_private *dev_priv = dev->dev_private; |
1819 | int latency = SNB_READ_WM0_LATENCY() * 100; /* In unit 0.1us */ |
1884 | int latency = dev_priv->wm.pri_latency[0] * 100; /* In unit 0.1us */ |
1820 | u32 val; |
1885 | u32 val; |
1821 | int fbc_wm, plane_wm, cursor_wm; |
1886 | int fbc_wm, plane_wm, cursor_wm; |
Line 1822... | Line 1887... | ||
1822 | unsigned int enabled; |
1887 | unsigned int enabled; |
Line 1869... | Line 1934... | ||
1869 | return; |
1934 | return; |
1870 | enabled = ffs(enabled) - 1; |
1935 | enabled = ffs(enabled) - 1; |
Line 1871... | Line 1936... | ||
1871 | 1936 | ||
1872 | /* WM1 */ |
1937 | /* WM1 */ |
1873 | if (!ironlake_compute_srwm(dev, 1, enabled, |
1938 | if (!ironlake_compute_srwm(dev, 1, enabled, |
1874 | SNB_READ_WM1_LATENCY() * 500, |
1939 | dev_priv->wm.pri_latency[1] * 500, |
1875 | &sandybridge_display_srwm_info, |
1940 | &sandybridge_display_srwm_info, |
1876 | &sandybridge_cursor_srwm_info, |
1941 | &sandybridge_cursor_srwm_info, |
1877 | &fbc_wm, &plane_wm, &cursor_wm)) |
1942 | &fbc_wm, &plane_wm, &cursor_wm)) |
Line 1878... | Line 1943... | ||
1878 | return; |
1943 | return; |
1879 | 1944 | ||
1880 | I915_WRITE(WM1_LP_ILK, |
1945 | I915_WRITE(WM1_LP_ILK, |
1881 | WM1_LP_SR_EN | |
1946 | WM1_LP_SR_EN | |
1882 | (SNB_READ_WM1_LATENCY() << WM1_LP_LATENCY_SHIFT) | |
1947 | (dev_priv->wm.pri_latency[1] << WM1_LP_LATENCY_SHIFT) | |
1883 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
1948 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
Line 1884... | Line 1949... | ||
1884 | (plane_wm << WM1_LP_SR_SHIFT) | |
1949 | (plane_wm << WM1_LP_SR_SHIFT) | |
1885 | cursor_wm); |
1950 | cursor_wm); |
1886 | 1951 | ||
1887 | /* WM2 */ |
1952 | /* WM2 */ |
1888 | if (!ironlake_compute_srwm(dev, 2, enabled, |
1953 | if (!ironlake_compute_srwm(dev, 2, enabled, |
1889 | SNB_READ_WM2_LATENCY() * 500, |
1954 | dev_priv->wm.pri_latency[2] * 500, |
1890 | &sandybridge_display_srwm_info, |
1955 | &sandybridge_display_srwm_info, |
Line 1891... | Line 1956... | ||
1891 | &sandybridge_cursor_srwm_info, |
1956 | &sandybridge_cursor_srwm_info, |
1892 | &fbc_wm, &plane_wm, &cursor_wm)) |
1957 | &fbc_wm, &plane_wm, &cursor_wm)) |
1893 | return; |
1958 | return; |
1894 | 1959 | ||
1895 | I915_WRITE(WM2_LP_ILK, |
1960 | I915_WRITE(WM2_LP_ILK, |
1896 | WM2_LP_EN | |
1961 | WM2_LP_EN | |
Line 1897... | Line 1962... | ||
1897 | (SNB_READ_WM2_LATENCY() << WM1_LP_LATENCY_SHIFT) | |
1962 | (dev_priv->wm.pri_latency[2] << WM1_LP_LATENCY_SHIFT) | |
1898 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
1963 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
1899 | (plane_wm << WM1_LP_SR_SHIFT) | |
1964 | (plane_wm << WM1_LP_SR_SHIFT) | |
1900 | cursor_wm); |
1965 | cursor_wm); |
1901 | 1966 | ||
1902 | /* WM3 */ |
1967 | /* WM3 */ |
1903 | if (!ironlake_compute_srwm(dev, 3, enabled, |
1968 | if (!ironlake_compute_srwm(dev, 3, enabled, |
Line 1904... | Line 1969... | ||
1904 | SNB_READ_WM3_LATENCY() * 500, |
1969 | dev_priv->wm.pri_latency[3] * 500, |
1905 | &sandybridge_display_srwm_info, |
1970 | &sandybridge_display_srwm_info, |
1906 | &sandybridge_cursor_srwm_info, |
1971 | &sandybridge_cursor_srwm_info, |
1907 | &fbc_wm, &plane_wm, &cursor_wm)) |
1972 | &fbc_wm, &plane_wm, &cursor_wm)) |
1908 | return; |
1973 | return; |
1909 | 1974 | ||
1910 | I915_WRITE(WM3_LP_ILK, |
1975 | I915_WRITE(WM3_LP_ILK, |
Line 1911... | Line 1976... | ||
1911 | WM3_LP_EN | |
1976 | WM3_LP_EN | |
1912 | (SNB_READ_WM3_LATENCY() << WM1_LP_LATENCY_SHIFT) | |
1977 | (dev_priv->wm.pri_latency[3] << WM1_LP_LATENCY_SHIFT) | |
1913 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
1978 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
1914 | (plane_wm << WM1_LP_SR_SHIFT) | |
1979 | (plane_wm << WM1_LP_SR_SHIFT) | |
1915 | cursor_wm); |
1980 | cursor_wm); |
1916 | } |
1981 | } |
1917 | 1982 | ||
1918 | static void ivybridge_update_wm(struct drm_device *dev) |
1983 | static void ivybridge_update_wm(struct drm_device *dev) |
Line 1986... | Line 2051... | ||
1986 | return; |
2051 | return; |
1987 | enabled = ffs(enabled) - 1; |
2052 | enabled = ffs(enabled) - 1; |
Line 1988... | Line 2053... | ||
1988 | 2053 | ||
1989 | /* WM1 */ |
2054 | /* WM1 */ |
1990 | if (!ironlake_compute_srwm(dev, 1, enabled, |
2055 | if (!ironlake_compute_srwm(dev, 1, enabled, |
1991 | SNB_READ_WM1_LATENCY() * 500, |
2056 | dev_priv->wm.pri_latency[1] * 500, |
1992 | &sandybridge_display_srwm_info, |
2057 | &sandybridge_display_srwm_info, |
1993 | &sandybridge_cursor_srwm_info, |
2058 | &sandybridge_cursor_srwm_info, |
1994 | &fbc_wm, &plane_wm, &cursor_wm)) |
2059 | &fbc_wm, &plane_wm, &cursor_wm)) |
Line 1995... | Line 2060... | ||
1995 | return; |
2060 | return; |
1996 | 2061 | ||
1997 | I915_WRITE(WM1_LP_ILK, |
2062 | I915_WRITE(WM1_LP_ILK, |
1998 | WM1_LP_SR_EN | |
2063 | WM1_LP_SR_EN | |
1999 | (SNB_READ_WM1_LATENCY() << WM1_LP_LATENCY_SHIFT) | |
2064 | (dev_priv->wm.pri_latency[1] << WM1_LP_LATENCY_SHIFT) | |
2000 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
2065 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
Line 2001... | Line 2066... | ||
2001 | (plane_wm << WM1_LP_SR_SHIFT) | |
2066 | (plane_wm << WM1_LP_SR_SHIFT) | |
2002 | cursor_wm); |
2067 | cursor_wm); |
2003 | 2068 | ||
2004 | /* WM2 */ |
2069 | /* WM2 */ |
2005 | if (!ironlake_compute_srwm(dev, 2, enabled, |
2070 | if (!ironlake_compute_srwm(dev, 2, enabled, |
2006 | SNB_READ_WM2_LATENCY() * 500, |
2071 | dev_priv->wm.pri_latency[2] * 500, |
2007 | &sandybridge_display_srwm_info, |
2072 | &sandybridge_display_srwm_info, |
Line 2008... | Line 2073... | ||
2008 | &sandybridge_cursor_srwm_info, |
2073 | &sandybridge_cursor_srwm_info, |
2009 | &fbc_wm, &plane_wm, &cursor_wm)) |
2074 | &fbc_wm, &plane_wm, &cursor_wm)) |
2010 | return; |
2075 | return; |
2011 | 2076 | ||
2012 | I915_WRITE(WM2_LP_ILK, |
2077 | I915_WRITE(WM2_LP_ILK, |
2013 | WM2_LP_EN | |
2078 | WM2_LP_EN | |
Line 2014... | Line 2079... | ||
2014 | (SNB_READ_WM2_LATENCY() << WM1_LP_LATENCY_SHIFT) | |
2079 | (dev_priv->wm.pri_latency[2] << WM1_LP_LATENCY_SHIFT) | |
2015 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
2080 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
2016 | (plane_wm << WM1_LP_SR_SHIFT) | |
2081 | (plane_wm << WM1_LP_SR_SHIFT) | |
2017 | cursor_wm); |
2082 | cursor_wm); |
2018 | 2083 | ||
2019 | /* WM3, note we have to correct the cursor latency */ |
2084 | /* WM3, note we have to correct the cursor latency */ |
2020 | if (!ironlake_compute_srwm(dev, 3, enabled, |
2085 | if (!ironlake_compute_srwm(dev, 3, enabled, |
2021 | SNB_READ_WM3_LATENCY() * 500, |
2086 | dev_priv->wm.pri_latency[3] * 500, |
2022 | &sandybridge_display_srwm_info, |
2087 | &sandybridge_display_srwm_info, |
2023 | &sandybridge_cursor_srwm_info, |
2088 | &sandybridge_cursor_srwm_info, |
2024 | &fbc_wm, &plane_wm, &ignore_cursor_wm) || |
2089 | &fbc_wm, &plane_wm, &ignore_cursor_wm) || |
2025 | !ironlake_compute_srwm(dev, 3, enabled, |
2090 | !ironlake_compute_srwm(dev, 3, enabled, |
Line 2026... | Line 2091... | ||
2026 | 2 * SNB_READ_WM3_LATENCY() * 500, |
2091 | dev_priv->wm.cur_latency[3] * 500, |
2027 | &sandybridge_display_srwm_info, |
2092 | &sandybridge_display_srwm_info, |
2028 | &sandybridge_cursor_srwm_info, |
2093 | &sandybridge_cursor_srwm_info, |
2029 | &ignore_fbc_wm, &ignore_plane_wm, &cursor_wm)) |
2094 | &ignore_fbc_wm, &ignore_plane_wm, &cursor_wm)) |
2030 | return; |
2095 | return; |
2031 | 2096 | ||
2032 | I915_WRITE(WM3_LP_ILK, |
2097 | I915_WRITE(WM3_LP_ILK, |
Line -... | Line 2098... | ||
- | 2098 | WM3_LP_EN | |
|
- | 2099 | (dev_priv->wm.pri_latency[3] << WM1_LP_LATENCY_SHIFT) | |
|
- | 2100 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
|
- | 2101 | (plane_wm << WM1_LP_SR_SHIFT) | |
|
- | 2102 | cursor_wm); |
|
- | 2103 | } |
|
- | 2104 | ||
- | 2105 | static uint32_t ilk_pipe_pixel_rate(struct drm_device *dev, |
|
- | 2106 | struct drm_crtc *crtc) |
|
- | 2107 | { |
|
- | 2108 | struct intel_crtc *intel_crtc = to_intel_crtc(crtc); |
|
- | 2109 | uint32_t pixel_rate; |
|
- | 2110 | ||
- | 2111 | pixel_rate = intel_crtc->config.adjusted_mode.clock; |
|
- | 2112 | ||
- | 2113 | /* We only use IF-ID interlacing. If we ever use PF-ID we'll need to |
|
- | 2114 | * adjust the pixel_rate here. */ |
|
- | 2115 | ||
- | 2116 | if (intel_crtc->config.pch_pfit.enabled) { |
|
- | 2117 | uint64_t pipe_w, pipe_h, pfit_w, pfit_h; |
|
- | 2118 | uint32_t pfit_size = intel_crtc->config.pch_pfit.size; |
|
- | 2119 | ||
- | 2120 | pipe_w = intel_crtc->config.requested_mode.hdisplay; |
|
- | 2121 | pipe_h = intel_crtc->config.requested_mode.vdisplay; |
|
- | 2122 | pfit_w = (pfit_size >> 16) & 0xFFFF; |
|
- | 2123 | pfit_h = pfit_size & 0xFFFF; |
|
- | 2124 | if (pipe_w < pfit_w) |
|
- | 2125 | pipe_w = pfit_w; |
|
- | 2126 | if (pipe_h < pfit_h) |
|
- | 2127 | pipe_h = pfit_h; |
|
- | 2128 | ||
- | 2129 | pixel_rate = div_u64((uint64_t) pixel_rate * pipe_w * pipe_h, |
|
- | 2130 | pfit_w * pfit_h); |
|
- | 2131 | } |
|
- | 2132 | ||
- | 2133 | return pixel_rate; |
|
- | 2134 | } |
|
- | 2135 | ||
- | 2136 | /* latency must be in 0.1us units. */ |
|
- | 2137 | static uint32_t ilk_wm_method1(uint32_t pixel_rate, uint8_t bytes_per_pixel, |
|
- | 2138 | uint32_t latency) |
|
- | 2139 | { |
|
- | 2140 | uint64_t ret; |
|
- | 2141 | ||
- | 2142 | if (WARN(latency == 0, "Latency value missing\n")) |
|
- | 2143 | return UINT_MAX; |
|
- | 2144 | ||
- | 2145 | ret = (uint64_t) pixel_rate * bytes_per_pixel * latency; |
|
- | 2146 | ret = DIV_ROUND_UP_ULL(ret, 64 * 10000) + 2; |
|
- | 2147 | ||
- | 2148 | return ret; |
|
- | 2149 | } |
|
- | 2150 | ||
- | 2151 | /* latency must be in 0.1us units. */ |
|
- | 2152 | static uint32_t ilk_wm_method2(uint32_t pixel_rate, uint32_t pipe_htotal, |
|
- | 2153 | uint32_t horiz_pixels, uint8_t bytes_per_pixel, |
|
- | 2154 | uint32_t latency) |
|
- | 2155 | { |
|
- | 2156 | uint32_t ret; |
|
2033 | WM3_LP_EN | |
2157 | |
- | 2158 | if (WARN(latency == 0, "Latency value missing\n")) |
|
- | 2159 | return UINT_MAX; |
|
- | 2160 | ||
- | 2161 | ret = (latency * pixel_rate) / (pipe_htotal * 10000); |
|
- | 2162 | ret = (ret + 1) * horiz_pixels * bytes_per_pixel; |
|
- | 2163 | ret = DIV_ROUND_UP(ret, 64) + 2; |
|
- | 2164 | return ret; |
|
- | 2165 | } |
|
- | 2166 | ||
- | 2167 | static uint32_t ilk_wm_fbc(uint32_t pri_val, uint32_t horiz_pixels, |
|
- | 2168 | uint8_t bytes_per_pixel) |
|
- | 2169 | { |
|
- | 2170 | return DIV_ROUND_UP(pri_val * 64, horiz_pixels * bytes_per_pixel) + 2; |
|
- | 2171 | } |
|
- | 2172 | ||
- | 2173 | struct hsw_pipe_wm_parameters { |
|
- | 2174 | bool active; |
|
- | 2175 | uint32_t pipe_htotal; |
|
- | 2176 | uint32_t pixel_rate; |
|
- | 2177 | struct intel_plane_wm_parameters pri; |
|
- | 2178 | struct intel_plane_wm_parameters spr; |
|
- | 2179 | struct intel_plane_wm_parameters cur; |
|
- | 2180 | }; |
|
- | 2181 | ||
- | 2182 | struct hsw_wm_maximums { |
|
- | 2183 | uint16_t pri; |
|
- | 2184 | uint16_t spr; |
|
- | 2185 | uint16_t cur; |
|
- | 2186 | uint16_t fbc; |
|
- | 2187 | }; |
|
- | 2188 | ||
- | 2189 | struct hsw_wm_values { |
|
- | 2190 | uint32_t wm_pipe[3]; |
|
- | 2191 | uint32_t wm_lp[3]; |
|
- | 2192 | uint32_t wm_lp_spr[3]; |
|
- | 2193 | uint32_t wm_linetime[3]; |
|
- | 2194 | bool enable_fbc_wm; |
|
- | 2195 | }; |
|
- | 2196 | ||
- | 2197 | /* used in computing the new watermarks state */ |
|
- | 2198 | struct intel_wm_config { |
|
- | 2199 | unsigned int num_pipes_active; |
|
- | 2200 | bool sprites_enabled; |
|
- | 2201 | bool sprites_scaled; |
|
- | 2202 | bool fbc_wm_enabled; |
|
- | 2203 | }; |
|
- | 2204 | ||
- | 2205 | /* |
|
- | 2206 | * For both WM_PIPE and WM_LP. |
|
- | 2207 | * mem_value must be in 0.1us units. |
|
- | 2208 | */ |
|
- | 2209 | static uint32_t ilk_compute_pri_wm(struct hsw_pipe_wm_parameters *params, |
|
- | 2210 | uint32_t mem_value, |
|
- | 2211 | bool is_lp) |
|
- | 2212 | { |
|
- | 2213 | uint32_t method1, method2; |
|
- | 2214 | ||
- | 2215 | if (!params->active || !params->pri.enabled) |
|
- | 2216 | return 0; |
|
- | 2217 | ||
- | 2218 | method1 = ilk_wm_method1(params->pixel_rate, |
|
- | 2219 | params->pri.bytes_per_pixel, |
|
- | 2220 | mem_value); |
|
- | 2221 | ||
- | 2222 | if (!is_lp) |
|
- | 2223 | return method1; |
|
- | 2224 | ||
- | 2225 | method2 = ilk_wm_method2(params->pixel_rate, |
|
- | 2226 | params->pipe_htotal, |
|
- | 2227 | params->pri.horiz_pixels, |
|
- | 2228 | params->pri.bytes_per_pixel, |
|
- | 2229 | mem_value); |
|
- | 2230 | ||
- | 2231 | return min(method1, method2); |
|
- | 2232 | } |
|
- | 2233 | ||
- | 2234 | /* |
|
- | 2235 | * For both WM_PIPE and WM_LP. |
|
- | 2236 | * mem_value must be in 0.1us units. |
|
- | 2237 | */ |
|
- | 2238 | static uint32_t ilk_compute_spr_wm(struct hsw_pipe_wm_parameters *params, |
|
- | 2239 | uint32_t mem_value) |
|
- | 2240 | { |
|
- | 2241 | uint32_t method1, method2; |
|
- | 2242 | ||
- | 2243 | if (!params->active || !params->spr.enabled) |
|
- | 2244 | return 0; |
|
- | 2245 | ||
- | 2246 | method1 = ilk_wm_method1(params->pixel_rate, |
|
- | 2247 | params->spr.bytes_per_pixel, |
|
- | 2248 | mem_value); |
|
- | 2249 | method2 = ilk_wm_method2(params->pixel_rate, |
|
- | 2250 | params->pipe_htotal, |
|
- | 2251 | params->spr.horiz_pixels, |
|
- | 2252 | params->spr.bytes_per_pixel, |
|
- | 2253 | mem_value); |
|
- | 2254 | return min(method1, method2); |
|
- | 2255 | } |
|
- | 2256 | ||
- | 2257 | /* |
|
- | 2258 | * For both WM_PIPE and WM_LP. |
|
- | 2259 | * mem_value must be in 0.1us units. |
|
- | 2260 | */ |
|
- | 2261 | static uint32_t ilk_compute_cur_wm(struct hsw_pipe_wm_parameters *params, |
|
- | 2262 | uint32_t mem_value) |
|
- | 2263 | { |
|
- | 2264 | if (!params->active || !params->cur.enabled) |
|
- | 2265 | return 0; |
|
- | 2266 | ||
- | 2267 | return ilk_wm_method2(params->pixel_rate, |
|
- | 2268 | params->pipe_htotal, |
|
- | 2269 | params->cur.horiz_pixels, |
|
- | 2270 | params->cur.bytes_per_pixel, |
|
- | 2271 | mem_value); |
|
- | 2272 | } |
|
- | 2273 | ||
- | 2274 | /* Only for WM_LP. */ |
|
- | 2275 | static uint32_t ilk_compute_fbc_wm(struct hsw_pipe_wm_parameters *params, |
|
- | 2276 | uint32_t pri_val) |
|
- | 2277 | { |
|
- | 2278 | if (!params->active || !params->pri.enabled) |
|
- | 2279 | return 0; |
|
- | 2280 | ||
- | 2281 | return ilk_wm_fbc(pri_val, |
|
- | 2282 | params->pri.horiz_pixels, |
|
- | 2283 | params->pri.bytes_per_pixel); |
|
- | 2284 | } |
|
- | 2285 | ||
- | 2286 | static unsigned int ilk_display_fifo_size(const struct drm_device *dev) |
|
- | 2287 | { |
|
- | 2288 | if (INTEL_INFO(dev)->gen >= 7) |
|
- | 2289 | return 768; |
|
- | 2290 | else |
|
- | 2291 | return 512; |
|
- | 2292 | } |
|
- | 2293 | ||
- | 2294 | /* Calculate the maximum primary/sprite plane watermark */ |
|
- | 2295 | static unsigned int ilk_plane_wm_max(const struct drm_device *dev, |
|
- | 2296 | int level, |
|
- | 2297 | const struct intel_wm_config *config, |
|
- | 2298 | enum intel_ddb_partitioning ddb_partitioning, |
|
- | 2299 | bool is_sprite) |
|
- | 2300 | { |
|
- | 2301 | unsigned int fifo_size = ilk_display_fifo_size(dev); |
|
- | 2302 | unsigned int max; |
|
- | 2303 | ||
- | 2304 | /* if sprites aren't enabled, sprites get nothing */ |
|
- | 2305 | if (is_sprite && !config->sprites_enabled) |
|
- | 2306 | return 0; |
|
- | 2307 | ||
- | 2308 | /* HSW allows LP1+ watermarks even with multiple pipes */ |
|
- | 2309 | if (level == 0 || config->num_pipes_active > 1) { |
|
- | 2310 | fifo_size /= INTEL_INFO(dev)->num_pipes; |
|
- | 2311 | ||
- | 2312 | /* |
|
- | 2313 | * For some reason the non self refresh |
|
- | 2314 | * FIFO size is only half of the self |
|
- | 2315 | * refresh FIFO size on ILK/SNB. |
|
- | 2316 | */ |
|
- | 2317 | if (INTEL_INFO(dev)->gen <= 6) |
|
- | 2318 | fifo_size /= 2; |
|
- | 2319 | } |
|
- | 2320 | ||
- | 2321 | if (config->sprites_enabled) { |
|
- | 2322 | /* level 0 is always calculated with 1:1 split */ |
|
- | 2323 | if (level > 0 && ddb_partitioning == INTEL_DDB_PART_5_6) { |
|
- | 2324 | if (is_sprite) |
|
- | 2325 | fifo_size *= 5; |
|
- | 2326 | fifo_size /= 6; |
|
- | 2327 | } else { |
|
- | 2328 | fifo_size /= 2; |
|
- | 2329 | } |
|
- | 2330 | } |
|
- | 2331 | ||
- | 2332 | /* clamp to max that the registers can hold */ |
|
- | 2333 | if (INTEL_INFO(dev)->gen >= 7) |
|
- | 2334 | /* IVB/HSW primary/sprite plane watermarks */ |
|
- | 2335 | max = level == 0 ? 127 : 1023; |
|
- | 2336 | else if (!is_sprite) |
|
- | 2337 | /* ILK/SNB primary plane watermarks */ |
|
- | 2338 | max = level == 0 ? 127 : 511; |
|
- | 2339 | else |
|
- | 2340 | /* ILK/SNB sprite plane watermarks */ |
|
- | 2341 | max = level == 0 ? 63 : 255; |
|
- | 2342 | ||
- | 2343 | return min(fifo_size, max); |
|
- | 2344 | } |
|
- | 2345 | ||
- | 2346 | /* Calculate the maximum cursor plane watermark */ |
|
- | 2347 | static unsigned int ilk_cursor_wm_max(const struct drm_device *dev, |
|
- | 2348 | int level, |
|
- | 2349 | const struct intel_wm_config *config) |
|
- | 2350 | { |
|
- | 2351 | /* HSW LP1+ watermarks w/ multiple pipes */ |
|
- | 2352 | if (level > 0 && config->num_pipes_active > 1) |
|
- | 2353 | return 64; |
|
- | 2354 | ||
- | 2355 | /* otherwise just report max that registers can hold */ |
|
- | 2356 | if (INTEL_INFO(dev)->gen >= 7) |
|
- | 2357 | return level == 0 ? 63 : 255; |
|
- | 2358 | else |
|
- | 2359 | return level == 0 ? 31 : 63; |
|
- | 2360 | } |
|
- | 2361 | ||
2034 | (SNB_READ_WM3_LATENCY() << WM1_LP_LATENCY_SHIFT) | |
2362 | /* Calculate the maximum FBC watermark */ |
- | 2363 | static unsigned int ilk_fbc_wm_max(void) |
|
- | 2364 | { |
|
- | 2365 | /* max that registers can hold */ |
|
- | 2366 | return 15; |
|
- | 2367 | } |
|
- | 2368 | ||
- | 2369 | static void ilk_wm_max(struct drm_device *dev, |
|
- | 2370 | int level, |
|
- | 2371 | const struct intel_wm_config *config, |
|
- | 2372 | enum intel_ddb_partitioning ddb_partitioning, |
|
- | 2373 | struct hsw_wm_maximums *max) |
|
- | 2374 | { |
|
- | 2375 | max->pri = ilk_plane_wm_max(dev, level, config, ddb_partitioning, false); |
|
- | 2376 | max->spr = ilk_plane_wm_max(dev, level, config, ddb_partitioning, true); |
|
- | 2377 | max->cur = ilk_cursor_wm_max(dev, level, config); |
|
- | 2378 | max->fbc = ilk_fbc_wm_max(); |
|
- | 2379 | } |
|
- | 2380 | ||
- | 2381 | static bool ilk_check_wm(int level, |
|
- | 2382 | const struct hsw_wm_maximums *max, |
|
- | 2383 | struct intel_wm_level *result) |
|
- | 2384 | { |
|
- | 2385 | bool ret; |
|
- | 2386 | ||
- | 2387 | /* already determined to be invalid? */ |
|
- | 2388 | if (!result->enable) |
|
- | 2389 | return false; |
|
- | 2390 | ||
- | 2391 | result->enable = result->pri_val <= max->pri && |
|
- | 2392 | result->spr_val <= max->spr && |
|
- | 2393 | result->cur_val <= max->cur; |
|
- | 2394 | ||
- | 2395 | ret = result->enable; |
|
- | 2396 | ||
- | 2397 | /* |
|
- | 2398 | * HACK until we can pre-compute everything, |
|
- | 2399 | * and thus fail gracefully if LP0 watermarks |
|
- | 2400 | * are exceeded... |
|
- | 2401 | */ |
|
- | 2402 | if (level == 0 && !result->enable) { |
|
- | 2403 | if (result->pri_val > max->pri) |
|
- | 2404 | DRM_DEBUG_KMS("Primary WM%d too large %u (max %u)\n", |
|
- | 2405 | level, result->pri_val, max->pri); |
|
- | 2406 | if (result->spr_val > max->spr) |
|
- | 2407 | DRM_DEBUG_KMS("Sprite WM%d too large %u (max %u)\n", |
|
- | 2408 | level, result->spr_val, max->spr); |
|
- | 2409 | if (result->cur_val > max->cur) |
|
- | 2410 | DRM_DEBUG_KMS("Cursor WM%d too large %u (max %u)\n", |
|
- | 2411 | level, result->cur_val, max->cur); |
|
- | 2412 | ||
- | 2413 | result->pri_val = min_t(uint32_t, result->pri_val, max->pri); |
|
- | 2414 | result->spr_val = min_t(uint32_t, result->spr_val, max->spr); |
|
- | 2415 | result->cur_val = min_t(uint32_t, result->cur_val, max->cur); |
|
- | 2416 | result->enable = true; |
|
- | 2417 | } |
|
- | 2418 | ||
- | 2419 | DRM_DEBUG_KMS("WM%d: %sabled\n", level, result->enable ? "en" : "dis"); |
|
2035 | (fbc_wm << WM1_LP_FBC_SHIFT) | |
2420 | |
- | 2421 | return ret; |
|
- | 2422 | } |
|
- | 2423 | ||
- | 2424 | static void ilk_compute_wm_level(struct drm_i915_private *dev_priv, |
|
- | 2425 | int level, |
|
- | 2426 | struct hsw_pipe_wm_parameters *p, |
|
- | 2427 | struct intel_wm_level *result) |
|
- | 2428 | { |
|
- | 2429 | uint16_t pri_latency = dev_priv->wm.pri_latency[level]; |
|
- | 2430 | uint16_t spr_latency = dev_priv->wm.spr_latency[level]; |
|
- | 2431 | uint16_t cur_latency = dev_priv->wm.cur_latency[level]; |
|
- | 2432 | ||
- | 2433 | /* WM1+ latency values stored in 0.5us units */ |
|
- | 2434 | if (level > 0) { |
|
- | 2435 | pri_latency *= 5; |
|
- | 2436 | spr_latency *= 5; |
|
- | 2437 | cur_latency *= 5; |
|
- | 2438 | } |
|
- | 2439 | ||
- | 2440 | result->pri_val = ilk_compute_pri_wm(p, pri_latency, level); |
|
- | 2441 | result->spr_val = ilk_compute_spr_wm(p, spr_latency); |
|
- | 2442 | result->cur_val = ilk_compute_cur_wm(p, cur_latency); |
|
- | 2443 | result->fbc_val = ilk_compute_fbc_wm(p, result->pri_val); |
|
- | 2444 | result->enable = true; |
|
- | 2445 | } |
|
- | 2446 | ||
- | 2447 | static bool hsw_compute_lp_wm(struct drm_i915_private *dev_priv, |
|
- | 2448 | int level, struct hsw_wm_maximums *max, |
|
- | 2449 | struct hsw_pipe_wm_parameters *params, |
|
- | 2450 | struct intel_wm_level *result) |
|
- | 2451 | { |
|
- | 2452 | enum pipe pipe; |
|
- | 2453 | struct intel_wm_level res[3]; |
|
- | 2454 | ||
- | 2455 | for (pipe = PIPE_A; pipe <= PIPE_C; pipe++) |
|
- | 2456 | ilk_compute_wm_level(dev_priv, level, ¶ms[pipe], &res[pipe]); |
|
- | 2457 | ||
- | 2458 | result->pri_val = max3(res[0].pri_val, res[1].pri_val, res[2].pri_val); |
|
- | 2459 | result->spr_val = max3(res[0].spr_val, res[1].spr_val, res[2].spr_val); |
|
- | 2460 | result->cur_val = max3(res[0].cur_val, res[1].cur_val, res[2].cur_val); |
|
- | 2461 | result->fbc_val = max3(res[0].fbc_val, res[1].fbc_val, res[2].fbc_val); |
|
- | 2462 | result->enable = true; |
|
- | 2463 | ||
- | 2464 | return ilk_check_wm(level, max, result); |
|
- | 2465 | } |
|
- | 2466 | ||
- | 2467 | static uint32_t hsw_compute_wm_pipe(struct drm_i915_private *dev_priv, |
|
- | 2468 | enum pipe pipe, |
|
- | 2469 | struct hsw_pipe_wm_parameters *params) |
|
- | 2470 | { |
|
- | 2471 | uint32_t pri_val, cur_val, spr_val; |
|
- | 2472 | /* WM0 latency values stored in 0.1us units */ |
|
- | 2473 | uint16_t pri_latency = dev_priv->wm.pri_latency[0]; |
|
- | 2474 | uint16_t spr_latency = dev_priv->wm.spr_latency[0]; |
|
- | 2475 | uint16_t cur_latency = dev_priv->wm.cur_latency[0]; |
|
- | 2476 | ||
- | 2477 | pri_val = ilk_compute_pri_wm(params, pri_latency, false); |
|
- | 2478 | spr_val = ilk_compute_spr_wm(params, spr_latency); |
|
- | 2479 | cur_val = ilk_compute_cur_wm(params, cur_latency); |
|
- | 2480 | ||
- | 2481 | WARN(pri_val > 127, |
|
- | 2482 | "Primary WM error, mode not supported for pipe %c\n", |
|
- | 2483 | pipe_name(pipe)); |
|
- | 2484 | WARN(spr_val > 127, |
|
- | 2485 | "Sprite WM error, mode not supported for pipe %c\n", |
|
- | 2486 | pipe_name(pipe)); |
|
- | 2487 | WARN(cur_val > 63, |
|
- | 2488 | "Cursor WM error, mode not supported for pipe %c\n", |
|
- | 2489 | pipe_name(pipe)); |
|
- | 2490 | ||
2036 | (plane_wm << WM1_LP_SR_SHIFT) | |
2491 | return (pri_val << WM0_PIPE_PLANE_SHIFT) | |
2037 | cursor_wm); |
2492 | (spr_val << WM0_PIPE_SPRITE_SHIFT) | |
- | 2493 | cur_val; |
|
- | 2494 | } |
|
2038 | } |
2495 | |
Line 2039... | Line 2496... | ||
2039 | 2496 | static uint32_t |
|
2040 | static void |
2497 | hsw_compute_linetime_wm(struct drm_device *dev, struct drm_crtc *crtc) |
Line 2041... | Line 2498... | ||
2041 | haswell_update_linetime_wm(struct drm_device *dev, int pipe, |
2498 | { |
2042 | struct drm_display_mode *mode) |
2499 | struct drm_i915_private *dev_priv = dev->dev_private; |
2043 | { |
2500 | struct intel_crtc *intel_crtc = to_intel_crtc(crtc); |
- | 2501 | struct drm_display_mode *mode = &intel_crtc->config.adjusted_mode; |
|
2044 | struct drm_i915_private *dev_priv = dev->dev_private; |
2502 | u32 linetime, ips_linetime; |
2045 | u32 temp; |
2503 | |
Line -... | Line 2504... | ||
- | 2504 | if (!intel_crtc_active(crtc)) |
|
- | 2505 | return 0; |
|
- | 2506 | ||
- | 2507 | /* The WM are computed with base on how long it takes to fill a single |
|
- | 2508 | * row at the given clock rate, multiplied by 8. |
|
- | 2509 | * */ |
|
- | 2510 | linetime = DIV_ROUND_CLOSEST(mode->htotal * 1000 * 8, mode->clock); |
|
- | 2511 | ips_linetime = DIV_ROUND_CLOSEST(mode->htotal * 1000 * 8, |
|
- | 2512 | intel_ddi_get_cdclk_freq(dev_priv)); |
|
- | 2513 | ||
- | 2514 | return PIPE_WM_LINETIME_IPS_LINETIME(ips_linetime) | |
|
- | 2515 | PIPE_WM_LINETIME_TIME(linetime); |
|
- | 2516 | } |
|
- | 2517 | ||
- | 2518 | static void intel_read_wm_latency(struct drm_device *dev, uint16_t wm[5]) |
|
- | 2519 | { |
|
- | 2520 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 2521 | ||
- | 2522 | if (IS_HASWELL(dev)) { |
|
- | 2523 | uint64_t sskpd = I915_READ64(MCH_SSKPD); |
|
- | 2524 | ||
- | 2525 | wm[0] = (sskpd >> 56) & 0xFF; |
|
- | 2526 | if (wm[0] == 0) |
|
- | 2527 | wm[0] = sskpd & 0xF; |
|
- | 2528 | wm[1] = (sskpd >> 4) & 0xFF; |
|
- | 2529 | wm[2] = (sskpd >> 12) & 0xFF; |
|
- | 2530 | wm[3] = (sskpd >> 20) & 0x1FF; |
|
- | 2531 | wm[4] = (sskpd >> 32) & 0x1FF; |
|
- | 2532 | } else if (INTEL_INFO(dev)->gen >= 6) { |
|
- | 2533 | uint32_t sskpd = I915_READ(MCH_SSKPD); |
|
- | 2534 | ||
- | 2535 | wm[0] = (sskpd >> SSKPD_WM0_SHIFT) & SSKPD_WM_MASK; |
|
- | 2536 | wm[1] = (sskpd >> SSKPD_WM1_SHIFT) & SSKPD_WM_MASK; |
|
- | 2537 | wm[2] = (sskpd >> SSKPD_WM2_SHIFT) & SSKPD_WM_MASK; |
|
- | 2538 | wm[3] = (sskpd >> SSKPD_WM3_SHIFT) & SSKPD_WM_MASK; |
|
- | 2539 | } else if (INTEL_INFO(dev)->gen >= 5) { |
|
- | 2540 | uint32_t mltr = I915_READ(MLTR_ILK); |
|
- | 2541 | ||
- | 2542 | /* ILK primary LP0 latency is 700 ns */ |
|
- | 2543 | wm[0] = 7; |
|
- | 2544 | wm[1] = (mltr >> MLTR_WM1_SHIFT) & ILK_SRLT_MASK; |
|
- | 2545 | wm[2] = (mltr >> MLTR_WM2_SHIFT) & ILK_SRLT_MASK; |
|
- | 2546 | } |
|
- | 2547 | } |
|
- | 2548 | ||
- | 2549 | static void intel_fixup_spr_wm_latency(struct drm_device *dev, uint16_t wm[5]) |
|
- | 2550 | { |
|
- | 2551 | /* ILK sprite LP0 latency is 1300 ns */ |
|
- | 2552 | if (INTEL_INFO(dev)->gen == 5) |
|
- | 2553 | wm[0] = 13; |
|
- | 2554 | } |
|
- | 2555 | ||
- | 2556 | static void intel_fixup_cur_wm_latency(struct drm_device *dev, uint16_t wm[5]) |
|
- | 2557 | { |
|
- | 2558 | /* ILK cursor LP0 latency is 1300 ns */ |
|
- | 2559 | if (INTEL_INFO(dev)->gen == 5) |
|
- | 2560 | wm[0] = 13; |
|
- | 2561 | ||
- | 2562 | /* WaDoubleCursorLP3Latency:ivb */ |
|
- | 2563 | if (IS_IVYBRIDGE(dev)) |
|
- | 2564 | wm[3] *= 2; |
|
- | 2565 | } |
|
- | 2566 | ||
- | 2567 | static void intel_print_wm_latency(struct drm_device *dev, |
|
- | 2568 | const char *name, |
|
- | 2569 | const uint16_t wm[5]) |
|
- | 2570 | { |
|
- | 2571 | int level, max_level; |
|
- | 2572 | ||
- | 2573 | /* how many WM levels are we expecting */ |
|
- | 2574 | if (IS_HASWELL(dev)) |
|
- | 2575 | max_level = 4; |
|
- | 2576 | else if (INTEL_INFO(dev)->gen >= 6) |
|
- | 2577 | max_level = 3; |
|
- | 2578 | else |
|
- | 2579 | max_level = 2; |
|
- | 2580 | ||
- | 2581 | for (level = 0; level <= max_level; level++) { |
|
- | 2582 | unsigned int latency = wm[level]; |
|
- | 2583 | ||
- | 2584 | if (latency == 0) { |
|
- | 2585 | DRM_ERROR("%s WM%d latency not provided\n", |
|
- | 2586 | name, level); |
|
- | 2587 | continue; |
|
- | 2588 | } |
|
- | 2589 | ||
- | 2590 | /* WM1+ latency values in 0.5us units */ |
|
- | 2591 | if (level > 0) |
|
- | 2592 | latency *= 5; |
|
- | 2593 | ||
- | 2594 | DRM_DEBUG_KMS("%s WM%d latency %u (%u.%u usec)\n", |
|
- | 2595 | name, level, wm[level], |
|
- | 2596 | latency / 10, latency % 10); |
|
- | 2597 | } |
|
- | 2598 | } |
|
- | 2599 | ||
- | 2600 | static void intel_setup_wm_latency(struct drm_device *dev) |
|
- | 2601 | { |
|
- | 2602 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 2603 | ||
- | 2604 | intel_read_wm_latency(dev, dev_priv->wm.pri_latency); |
|
- | 2605 | ||
- | 2606 | memcpy(dev_priv->wm.spr_latency, dev_priv->wm.pri_latency, |
|
- | 2607 | sizeof(dev_priv->wm.pri_latency)); |
|
- | 2608 | memcpy(dev_priv->wm.cur_latency, dev_priv->wm.pri_latency, |
|
- | 2609 | sizeof(dev_priv->wm.pri_latency)); |
|
- | 2610 | ||
- | 2611 | intel_fixup_spr_wm_latency(dev, dev_priv->wm.spr_latency); |
|
- | 2612 | intel_fixup_cur_wm_latency(dev, dev_priv->wm.cur_latency); |
|
- | 2613 | ||
- | 2614 | intel_print_wm_latency(dev, "Primary", dev_priv->wm.pri_latency); |
|
- | 2615 | intel_print_wm_latency(dev, "Sprite", dev_priv->wm.spr_latency); |
|
- | 2616 | intel_print_wm_latency(dev, "Cursor", dev_priv->wm.cur_latency); |
|
- | 2617 | } |
|
- | 2618 | ||
- | 2619 | static void hsw_compute_wm_parameters(struct drm_device *dev, |
|
- | 2620 | struct hsw_pipe_wm_parameters *params, |
|
- | 2621 | struct hsw_wm_maximums *lp_max_1_2, |
|
- | 2622 | struct hsw_wm_maximums *lp_max_5_6) |
|
- | 2623 | { |
|
- | 2624 | struct drm_crtc *crtc; |
|
- | 2625 | struct drm_plane *plane; |
|
- | 2626 | enum pipe pipe; |
|
- | 2627 | struct intel_wm_config config = {}; |
|
- | 2628 | ||
- | 2629 | list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) { |
|
- | 2630 | struct intel_crtc *intel_crtc = to_intel_crtc(crtc); |
|
- | 2631 | struct hsw_pipe_wm_parameters *p; |
|
- | 2632 | ||
- | 2633 | pipe = intel_crtc->pipe; |
|
- | 2634 | p = ¶ms[pipe]; |
|
- | 2635 | ||
- | 2636 | p->active = intel_crtc_active(crtc); |
|
- | 2637 | if (!p->active) |
|
- | 2638 | continue; |
|
- | 2639 | ||
- | 2640 | config.num_pipes_active++; |
|
- | 2641 | ||
- | 2642 | p->pipe_htotal = intel_crtc->config.adjusted_mode.htotal; |
|
- | 2643 | p->pixel_rate = ilk_pipe_pixel_rate(dev, crtc); |
|
- | 2644 | p->pri.bytes_per_pixel = crtc->fb->bits_per_pixel / 8; |
|
- | 2645 | p->cur.bytes_per_pixel = 4; |
|
- | 2646 | p->pri.horiz_pixels = |
|
- | 2647 | intel_crtc->config.requested_mode.hdisplay; |
|
- | 2648 | p->cur.horiz_pixels = 64; |
|
- | 2649 | /* TODO: for now, assume primary and cursor planes are always enabled. */ |
|
- | 2650 | p->pri.enabled = true; |
|
- | 2651 | p->cur.enabled = true; |
|
- | 2652 | } |
|
- | 2653 | ||
- | 2654 | list_for_each_entry(plane, &dev->mode_config.plane_list, head) { |
|
- | 2655 | struct intel_plane *intel_plane = to_intel_plane(plane); |
|
- | 2656 | struct hsw_pipe_wm_parameters *p; |
|
- | 2657 | ||
- | 2658 | pipe = intel_plane->pipe; |
|
2046 | 2659 | p = ¶ms[pipe]; |
|
- | 2660 | ||
- | 2661 | p->spr = intel_plane->wm; |
|
- | 2662 | ||
- | 2663 | config.sprites_enabled |= p->spr.enabled; |
|
- | 2664 | config.sprites_scaled |= p->spr.scaled; |
|
- | 2665 | } |
|
- | 2666 | ||
- | 2667 | ilk_wm_max(dev, 1, &config, INTEL_DDB_PART_1_2, lp_max_1_2); |
|
- | 2668 | ||
- | 2669 | /* 5/6 split only in single pipe config on IVB+ */ |
|
- | 2670 | if (INTEL_INFO(dev)->gen >= 7 && config.num_pipes_active <= 1) |
|
- | 2671 | ilk_wm_max(dev, 1, &config, INTEL_DDB_PART_5_6, lp_max_5_6); |
|
- | 2672 | else |
|
- | 2673 | *lp_max_5_6 = *lp_max_1_2; |
|
- | 2674 | } |
|
- | 2675 | ||
- | 2676 | static void hsw_compute_wm_results(struct drm_device *dev, |
|
- | 2677 | struct hsw_pipe_wm_parameters *params, |
|
- | 2678 | struct hsw_wm_maximums *lp_maximums, |
|
- | 2679 | struct hsw_wm_values *results) |
|
- | 2680 | { |
|
- | 2681 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 2682 | struct drm_crtc *crtc; |
|
- | 2683 | struct intel_wm_level lp_results[4] = {}; |
|
- | 2684 | enum pipe pipe; |
|
- | 2685 | int level, max_level, wm_lp; |
|
2047 | temp = I915_READ(PIPE_WM_LINETIME(pipe)); |
2686 | |
- | 2687 | for (level = 1; level <= 4; level++) |
|
- | 2688 | if (!hsw_compute_lp_wm(dev_priv, level, |
|
- | 2689 | lp_maximums, params, |
|
- | 2690 | &lp_results[level - 1])) |
|
- | 2691 | break; |
|
- | 2692 | max_level = level - 1; |
|
- | 2693 | ||
- | 2694 | memset(results, 0, sizeof(*results)); |
|
- | 2695 | ||
- | 2696 | /* The spec says it is preferred to disable FBC WMs instead of disabling |
|
- | 2697 | * a WM level. */ |
|
- | 2698 | results->enable_fbc_wm = true; |
|
- | 2699 | for (level = 1; level <= max_level; level++) { |
|
- | 2700 | if (lp_results[level - 1].fbc_val > lp_maximums->fbc) { |
|
- | 2701 | results->enable_fbc_wm = false; |
|
- | 2702 | lp_results[level - 1].fbc_val = 0; |
|
- | 2703 | } |
|
- | 2704 | } |
|
- | 2705 | ||
- | 2706 | for (wm_lp = 1; wm_lp <= 3; wm_lp++) { |
|
- | 2707 | const struct intel_wm_level *r; |
|
- | 2708 | ||
- | 2709 | level = (max_level == 4 && wm_lp > 1) ? wm_lp + 1 : wm_lp; |
|
- | 2710 | if (level > max_level) |
|
- | 2711 | break; |
|
- | 2712 | ||
- | 2713 | r = &lp_results[level - 1]; |
|
- | 2714 | results->wm_lp[wm_lp - 1] = HSW_WM_LP_VAL(level * 2, |
|
- | 2715 | r->fbc_val, |
|
- | 2716 | r->pri_val, |
|
- | 2717 | r->cur_val); |
|
- | 2718 | results->wm_lp_spr[wm_lp - 1] = r->spr_val; |
|
- | 2719 | } |
|
- | 2720 | ||
2048 | temp &= ~PIPE_WM_LINETIME_MASK; |
2721 | for_each_pipe(pipe) |
2049 | 2722 | results->wm_pipe[pipe] = hsw_compute_wm_pipe(dev_priv, pipe, |
|
- | 2723 | ¶ms[pipe]); |
|
- | 2724 | ||
- | 2725 | for_each_pipe(pipe) { |
|
- | 2726 | crtc = dev_priv->pipe_to_crtc_mapping[pipe]; |
|
- | 2727 | results->wm_linetime[pipe] = hsw_compute_linetime_wm(dev, crtc); |
|
- | 2728 | } |
|
- | 2729 | } |
|
- | 2730 | ||
- | 2731 | /* Find the result with the highest level enabled. Check for enable_fbc_wm in |
|
- | 2732 | * case both are at the same level. Prefer r1 in case they're the same. */ |
|
- | 2733 | static struct hsw_wm_values *hsw_find_best_result(struct hsw_wm_values *r1, |
|
- | 2734 | struct hsw_wm_values *r2) |
|
- | 2735 | { |
|
- | 2736 | int i, val_r1 = 0, val_r2 = 0; |
|
- | 2737 | ||
- | 2738 | for (i = 0; i < 3; i++) { |
|
- | 2739 | if (r1->wm_lp[i] & WM3_LP_EN) |
|
- | 2740 | val_r1 = r1->wm_lp[i] & WM1_LP_LATENCY_MASK; |
|
- | 2741 | if (r2->wm_lp[i] & WM3_LP_EN) |
|
- | 2742 | val_r2 = r2->wm_lp[i] & WM1_LP_LATENCY_MASK; |
|
- | 2743 | } |
|
- | 2744 | ||
- | 2745 | if (val_r1 == val_r2) { |
|
- | 2746 | if (r2->enable_fbc_wm && !r1->enable_fbc_wm) |
|
2050 | /* The WM are computed with base on how long it takes to fill a single |
2747 | return r2; |
2051 | * row at the given clock rate, multiplied by 8. |
2748 | else |
- | 2749 | return r1; |
|
2052 | * */ |
2750 | } else if (val_r1 > val_r2) { |
- | 2751 | return r1; |
|
- | 2752 | } else { |
|
- | 2753 | return r2; |
|
- | 2754 | } |
|
- | 2755 | } |
|
- | 2756 | ||
- | 2757 | /* |
|
- | 2758 | * The spec says we shouldn't write when we don't need, because every write |
|
Line -... | Line 2759... | ||
- | 2759 | * causes WMs to be re-evaluated, expending some power. |
|
- | 2760 | */ |
|
- | 2761 | static void hsw_write_wm_values(struct drm_i915_private *dev_priv, |
|
- | 2762 | struct hsw_wm_values *results, |
|
- | 2763 | enum intel_ddb_partitioning partitioning) |
|
- | 2764 | { |
|
- | 2765 | struct hsw_wm_values previous; |
|
- | 2766 | uint32_t val; |
|
- | 2767 | enum intel_ddb_partitioning prev_partitioning; |
|
- | 2768 | bool prev_enable_fbc_wm; |
|
- | 2769 | ||
- | 2770 | previous.wm_pipe[0] = I915_READ(WM0_PIPEA_ILK); |
|
- | 2771 | previous.wm_pipe[1] = I915_READ(WM0_PIPEB_ILK); |
|
- | 2772 | previous.wm_pipe[2] = I915_READ(WM0_PIPEC_IVB); |
|
- | 2773 | previous.wm_lp[0] = I915_READ(WM1_LP_ILK); |
|
- | 2774 | previous.wm_lp[1] = I915_READ(WM2_LP_ILK); |
|
- | 2775 | previous.wm_lp[2] = I915_READ(WM3_LP_ILK); |
|
- | 2776 | previous.wm_lp_spr[0] = I915_READ(WM1S_LP_ILK); |
|
- | 2777 | previous.wm_lp_spr[1] = I915_READ(WM2S_LP_IVB); |
|
- | 2778 | previous.wm_lp_spr[2] = I915_READ(WM3S_LP_IVB); |
|
- | 2779 | previous.wm_linetime[0] = I915_READ(PIPE_WM_LINETIME(PIPE_A)); |
|
- | 2780 | previous.wm_linetime[1] = I915_READ(PIPE_WM_LINETIME(PIPE_B)); |
|
- | 2781 | previous.wm_linetime[2] = I915_READ(PIPE_WM_LINETIME(PIPE_C)); |
|
- | 2782 | ||
- | 2783 | prev_partitioning = (I915_READ(WM_MISC) & WM_MISC_DATA_PARTITION_5_6) ? |
|
- | 2784 | INTEL_DDB_PART_5_6 : INTEL_DDB_PART_1_2; |
|
- | 2785 | ||
- | 2786 | prev_enable_fbc_wm = !(I915_READ(DISP_ARB_CTL) & DISP_FBC_WM_DIS); |
|
- | 2787 | ||
- | 2788 | if (memcmp(results->wm_pipe, previous.wm_pipe, |
|
- | 2789 | sizeof(results->wm_pipe)) == 0 && |
|
- | 2790 | memcmp(results->wm_lp, previous.wm_lp, |
|
- | 2791 | sizeof(results->wm_lp)) == 0 && |
|
- | 2792 | memcmp(results->wm_lp_spr, previous.wm_lp_spr, |
|
- | 2793 | sizeof(results->wm_lp_spr)) == 0 && |
|
- | 2794 | memcmp(results->wm_linetime, previous.wm_linetime, |
|
- | 2795 | sizeof(results->wm_linetime)) == 0 && |
|
- | 2796 | partitioning == prev_partitioning && |
|
- | 2797 | results->enable_fbc_wm == prev_enable_fbc_wm) |
|
- | 2798 | return; |
|
- | 2799 | ||
- | 2800 | if (previous.wm_lp[2] != 0) |
|
- | 2801 | I915_WRITE(WM3_LP_ILK, 0); |
|
- | 2802 | if (previous.wm_lp[1] != 0) |
|
- | 2803 | I915_WRITE(WM2_LP_ILK, 0); |
|
- | 2804 | if (previous.wm_lp[0] != 0) |
|
- | 2805 | I915_WRITE(WM1_LP_ILK, 0); |
|
- | 2806 | ||
- | 2807 | if (previous.wm_pipe[0] != results->wm_pipe[0]) |
|
2053 | temp |= PIPE_WM_LINETIME_TIME( |
2808 | I915_WRITE(WM0_PIPEA_ILK, results->wm_pipe[0]); |
- | 2809 | if (previous.wm_pipe[1] != results->wm_pipe[1]) |
|
- | 2810 | I915_WRITE(WM0_PIPEB_ILK, results->wm_pipe[1]); |
|
- | 2811 | if (previous.wm_pipe[2] != results->wm_pipe[2]) |
|
- | 2812 | I915_WRITE(WM0_PIPEC_IVB, results->wm_pipe[2]); |
|
- | 2813 | ||
- | 2814 | if (previous.wm_linetime[0] != results->wm_linetime[0]) |
|
- | 2815 | I915_WRITE(PIPE_WM_LINETIME(PIPE_A), results->wm_linetime[0]); |
|
- | 2816 | if (previous.wm_linetime[1] != results->wm_linetime[1]) |
|
- | 2817 | I915_WRITE(PIPE_WM_LINETIME(PIPE_B), results->wm_linetime[1]); |
|
- | 2818 | if (previous.wm_linetime[2] != results->wm_linetime[2]) |
|
- | 2819 | I915_WRITE(PIPE_WM_LINETIME(PIPE_C), results->wm_linetime[2]); |
|
- | 2820 | ||
- | 2821 | if (prev_partitioning != partitioning) { |
|
- | 2822 | val = I915_READ(WM_MISC); |
|
- | 2823 | if (partitioning == INTEL_DDB_PART_1_2) |
|
- | 2824 | val &= ~WM_MISC_DATA_PARTITION_5_6; |
|
- | 2825 | else |
|
- | 2826 | val |= WM_MISC_DATA_PARTITION_5_6; |
|
- | 2827 | I915_WRITE(WM_MISC, val); |
|
- | 2828 | } |
|
- | 2829 | ||
- | 2830 | if (prev_enable_fbc_wm != results->enable_fbc_wm) { |
|
- | 2831 | val = I915_READ(DISP_ARB_CTL); |
|
- | 2832 | if (results->enable_fbc_wm) |
|
- | 2833 | val &= ~DISP_FBC_WM_DIS; |
|
- | 2834 | else |
|
- | 2835 | val |= DISP_FBC_WM_DIS; |
|
- | 2836 | I915_WRITE(DISP_ARB_CTL, val); |
|
- | 2837 | } |
|
- | 2838 | ||
- | 2839 | if (previous.wm_lp_spr[0] != results->wm_lp_spr[0]) |
|
- | 2840 | I915_WRITE(WM1S_LP_ILK, results->wm_lp_spr[0]); |
|
- | 2841 | if (previous.wm_lp_spr[1] != results->wm_lp_spr[1]) |
|
- | 2842 | I915_WRITE(WM2S_LP_IVB, results->wm_lp_spr[1]); |
|
- | 2843 | if (previous.wm_lp_spr[2] != results->wm_lp_spr[2]) |
|
- | 2844 | I915_WRITE(WM3S_LP_IVB, results->wm_lp_spr[2]); |
|
- | 2845 | ||
- | 2846 | if (results->wm_lp[0] != 0) |
|
- | 2847 | I915_WRITE(WM1_LP_ILK, results->wm_lp[0]); |
|
- | 2848 | if (results->wm_lp[1] != 0) |
|
- | 2849 | I915_WRITE(WM2_LP_ILK, results->wm_lp[1]); |
|
- | 2850 | if (results->wm_lp[2] != 0) |
|
- | 2851 | I915_WRITE(WM3_LP_ILK, results->wm_lp[2]); |
|
- | 2852 | } |
|
- | 2853 | ||
- | 2854 | static void haswell_update_wm(struct drm_device *dev) |
|
- | 2855 | { |
|
- | 2856 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 2857 | struct hsw_wm_maximums lp_max_1_2, lp_max_5_6; |
|
- | 2858 | struct hsw_pipe_wm_parameters params[3]; |
|
- | 2859 | struct hsw_wm_values results_1_2, results_5_6, *best_results; |
|
- | 2860 | enum intel_ddb_partitioning partitioning; |
|
- | 2861 | ||
- | 2862 | hsw_compute_wm_parameters(dev, params, &lp_max_1_2, &lp_max_5_6); |
|
- | 2863 | ||
- | 2864 | hsw_compute_wm_results(dev, params, |
|
- | 2865 | &lp_max_1_2, &results_1_2); |
|
- | 2866 | if (lp_max_1_2.pri != lp_max_5_6.pri) { |
|
- | 2867 | hsw_compute_wm_results(dev, params, |
|
- | 2868 | &lp_max_5_6, &results_5_6); |
|
- | 2869 | best_results = hsw_find_best_result(&results_1_2, &results_5_6); |
|
- | 2870 | } else { |
|
- | 2871 | best_results = &results_1_2; |
|
- | 2872 | } |
|
- | 2873 | ||
- | 2874 | partitioning = (best_results == &results_1_2) ? |
|
- | 2875 | INTEL_DDB_PART_1_2 : INTEL_DDB_PART_5_6; |
|
- | 2876 | ||
- | 2877 | hsw_write_wm_values(dev_priv, best_results, partitioning); |
|
- | 2878 | } |
|
- | 2879 | ||
- | 2880 | static void haswell_update_sprite_wm(struct drm_plane *plane, |
|
- | 2881 | struct drm_crtc *crtc, |
|
2054 | ((mode->crtc_hdisplay * 1000) / mode->clock) * 8); |
2882 | uint32_t sprite_width, int pixel_size, |
Line 2055... | Line 2883... | ||
2055 | 2883 | bool enabled, bool scaled) |
|
2056 | /* IPS watermarks are only used by pipe A, and are ignored by |
2884 | { |
2057 | * pipes B and C. They are calculated similarly to the common |
2885 | struct intel_plane *intel_plane = to_intel_plane(plane); |
Line 2138... | Line 2966... | ||
2138 | *sprite_wm = entries + display->guard_size; |
2966 | *sprite_wm = entries + display->guard_size; |
Line 2139... | Line 2967... | ||
2139 | 2967 | ||
2140 | return *sprite_wm > 0x3ff ? false : true; |
2968 | return *sprite_wm > 0x3ff ? false : true; |
Line 2141... | Line 2969... | ||
2141 | } |
2969 | } |
- | 2970 | ||
2142 | 2971 | static void sandybridge_update_sprite_wm(struct drm_plane *plane, |
|
- | 2972 | struct drm_crtc *crtc, |
|
2143 | static void sandybridge_update_sprite_wm(struct drm_device *dev, int pipe, |
2973 | uint32_t sprite_width, int pixel_size, |
- | 2974 | bool enabled, bool scaled) |
|
2144 | uint32_t sprite_width, int pixel_size) |
2975 | { |
- | 2976 | struct drm_device *dev = plane->dev; |
|
2145 | { |
2977 | struct drm_i915_private *dev_priv = dev->dev_private; |
2146 | struct drm_i915_private *dev_priv = dev->dev_private; |
2978 | int pipe = to_intel_plane(plane)->pipe; |
2147 | int latency = SNB_READ_WM0_LATENCY() * 100; /* In unit 0.1us */ |
2979 | int latency = dev_priv->wm.spr_latency[0] * 100; /* In unit 0.1us */ |
2148 | u32 val; |
2980 | u32 val; |
Line -... | Line 2981... | ||
- | 2981 | int sprite_wm, reg; |
|
- | 2982 | int ret; |
|
- | 2983 | ||
2149 | int sprite_wm, reg; |
2984 | if (!enabled) |
2150 | int ret; |
2985 | return; |
2151 | 2986 | ||
2152 | switch (pipe) { |
2987 | switch (pipe) { |
2153 | case 0: |
2988 | case 0: |
Line 2165... | Line 3000... | ||
2165 | 3000 | ||
2166 | ret = sandybridge_compute_sprite_wm(dev, pipe, sprite_width, pixel_size, |
3001 | ret = sandybridge_compute_sprite_wm(dev, pipe, sprite_width, pixel_size, |
2167 | &sandybridge_display_wm_info, |
3002 | &sandybridge_display_wm_info, |
2168 | latency, &sprite_wm); |
3003 | latency, &sprite_wm); |
2169 | if (!ret) { |
3004 | if (!ret) { |
2170 | DRM_DEBUG_KMS("failed to compute sprite wm for pipe %d\n", |
3005 | DRM_DEBUG_KMS("failed to compute sprite wm for pipe %c\n", |
2171 | pipe); |
3006 | pipe_name(pipe)); |
2172 | return; |
3007 | return; |
Line 2173... | Line 3008... | ||
2173 | } |
3008 | } |
2174 | 3009 | ||
2175 | val = I915_READ(reg); |
3010 | val = I915_READ(reg); |
2176 | val &= ~WM0_PIPE_SPRITE_MASK; |
3011 | val &= ~WM0_PIPE_SPRITE_MASK; |
Line 2177... | Line 3012... | ||
2177 | I915_WRITE(reg, val | (sprite_wm << WM0_PIPE_SPRITE_SHIFT)); |
3012 | I915_WRITE(reg, val | (sprite_wm << WM0_PIPE_SPRITE_SHIFT)); |
2178 | DRM_DEBUG_KMS("sprite watermarks For pipe %d - %d\n", pipe, sprite_wm); |
3013 | DRM_DEBUG_KMS("sprite watermarks For pipe %c - %d\n", pipe_name(pipe), sprite_wm); |
2179 | 3014 | ||
2180 | 3015 | ||
2181 | ret = sandybridge_compute_sprite_srwm(dev, pipe, sprite_width, |
3016 | ret = sandybridge_compute_sprite_srwm(dev, pipe, sprite_width, |
2182 | pixel_size, |
3017 | pixel_size, |
2183 | &sandybridge_display_srwm_info, |
3018 | &sandybridge_display_srwm_info, |
2184 | SNB_READ_WM1_LATENCY() * 500, |
3019 | dev_priv->wm.spr_latency[1] * 500, |
2185 | &sprite_wm); |
3020 | &sprite_wm); |
2186 | if (!ret) { |
3021 | if (!ret) { |
2187 | DRM_DEBUG_KMS("failed to compute sprite lp1 wm on pipe %d\n", |
3022 | DRM_DEBUG_KMS("failed to compute sprite lp1 wm on pipe %c\n", |
Line 2188... | Line 3023... | ||
2188 | pipe); |
3023 | pipe_name(pipe)); |
Line 2195... | Line 3030... | ||
2195 | return; |
3030 | return; |
Line 2196... | Line 3031... | ||
2196 | 3031 | ||
2197 | ret = sandybridge_compute_sprite_srwm(dev, pipe, sprite_width, |
3032 | ret = sandybridge_compute_sprite_srwm(dev, pipe, sprite_width, |
2198 | pixel_size, |
3033 | pixel_size, |
2199 | &sandybridge_display_srwm_info, |
3034 | &sandybridge_display_srwm_info, |
2200 | SNB_READ_WM2_LATENCY() * 500, |
3035 | dev_priv->wm.spr_latency[2] * 500, |
2201 | &sprite_wm); |
3036 | &sprite_wm); |
2202 | if (!ret) { |
3037 | if (!ret) { |
2203 | DRM_DEBUG_KMS("failed to compute sprite lp2 wm on pipe %d\n", |
3038 | DRM_DEBUG_KMS("failed to compute sprite lp2 wm on pipe %c\n", |
2204 | pipe); |
3039 | pipe_name(pipe)); |
2205 | return; |
3040 | return; |
2206 | } |
3041 | } |
Line 2207... | Line 3042... | ||
2207 | I915_WRITE(WM2S_LP_IVB, sprite_wm); |
3042 | I915_WRITE(WM2S_LP_IVB, sprite_wm); |
2208 | 3043 | ||
2209 | ret = sandybridge_compute_sprite_srwm(dev, pipe, sprite_width, |
3044 | ret = sandybridge_compute_sprite_srwm(dev, pipe, sprite_width, |
2210 | pixel_size, |
3045 | pixel_size, |
2211 | &sandybridge_display_srwm_info, |
3046 | &sandybridge_display_srwm_info, |
2212 | SNB_READ_WM3_LATENCY() * 500, |
3047 | dev_priv->wm.spr_latency[3] * 500, |
2213 | &sprite_wm); |
3048 | &sprite_wm); |
2214 | if (!ret) { |
3049 | if (!ret) { |
2215 | DRM_DEBUG_KMS("failed to compute sprite lp3 wm on pipe %d\n", |
3050 | DRM_DEBUG_KMS("failed to compute sprite lp3 wm on pipe %c\n", |
2216 | pipe); |
3051 | pipe_name(pipe)); |
2217 | return; |
3052 | return; |
2218 | } |
3053 | } |
Line 2257... | Line 3092... | ||
2257 | 3092 | ||
2258 | if (dev_priv->display.update_wm) |
3093 | if (dev_priv->display.update_wm) |
2259 | dev_priv->display.update_wm(dev); |
3094 | dev_priv->display.update_wm(dev); |
Line 2260... | Line 3095... | ||
2260 | } |
3095 | } |
2261 | 3096 | ||
2262 | void intel_update_linetime_watermarks(struct drm_device *dev, |
- | |
2263 | int pipe, struct drm_display_mode *mode) |
- | |
2264 | { |
- | |
2265 | struct drm_i915_private *dev_priv = dev->dev_private; |
3097 | void intel_update_sprite_watermarks(struct drm_plane *plane, |
2266 | - | ||
2267 | if (dev_priv->display.update_linetime_wm) |
- | |
2268 | dev_priv->display.update_linetime_wm(dev, pipe, mode); |
- | |
2269 | } |
- | |
2270 | 3098 | struct drm_crtc *crtc, |
|
2271 | void intel_update_sprite_watermarks(struct drm_device *dev, int pipe, |
3099 | uint32_t sprite_width, int pixel_size, |
2272 | uint32_t sprite_width, int pixel_size) |
3100 | bool enabled, bool scaled) |
Line 2273... | Line 3101... | ||
2273 | { |
3101 | { |
2274 | struct drm_i915_private *dev_priv = dev->dev_private; |
3102 | struct drm_i915_private *dev_priv = plane->dev->dev_private; |
2275 | 3103 | ||
2276 | if (dev_priv->display.update_sprite_wm) |
3104 | if (dev_priv->display.update_sprite_wm) |
Line 2277... | Line 3105... | ||
2277 | dev_priv->display.update_sprite_wm(dev, pipe, sprite_width, |
3105 | dev_priv->display.update_sprite_wm(plane, crtc, sprite_width, |
2278 | pixel_size); |
3106 | pixel_size, enabled, scaled); |
2279 | } |
3107 | } |
Line 2290... | Line 3118... | ||
2290 | if (!ctx) { |
3118 | if (!ctx) { |
2291 | DRM_DEBUG("failed to alloc power context, RC6 disabled\n"); |
3119 | DRM_DEBUG("failed to alloc power context, RC6 disabled\n"); |
2292 | return NULL; |
3120 | return NULL; |
2293 | } |
3121 | } |
Line 2294... | Line 3122... | ||
2294 | 3122 | ||
2295 | ret = i915_gem_object_pin(ctx, 4096, true, false); |
3123 | ret = i915_gem_obj_ggtt_pin(ctx, 4096, true, false); |
2296 | if (ret) { |
3124 | if (ret) { |
2297 | DRM_ERROR("failed to pin power context: %d\n", ret); |
3125 | DRM_ERROR("failed to pin power context: %d\n", ret); |
2298 | goto err_unref; |
3126 | goto err_unref; |
Line 2500... | Line 3328... | ||
2500 | dev_priv->rps.cur_delay = val; |
3328 | dev_priv->rps.cur_delay = val; |
Line 2501... | Line 3329... | ||
2501 | 3329 | ||
2502 | trace_intel_gpu_freq_change(val * 50); |
3330 | trace_intel_gpu_freq_change(val * 50); |
Line -... | Line 3331... | ||
- | 3331 | } |
|
- | 3332 | ||
- | 3333 | /* |
|
- | 3334 | * Wait until the previous freq change has completed, |
|
- | 3335 | * or the timeout elapsed, and then update our notion |
|
- | 3336 | * of the current GPU frequency. |
|
- | 3337 | */ |
|
- | 3338 | static void vlv_update_rps_cur_delay(struct drm_i915_private *dev_priv) |
|
- | 3339 | { |
|
- | 3340 | u32 pval; |
|
- | 3341 | ||
- | 3342 | WARN_ON(!mutex_is_locked(&dev_priv->rps.hw_lock)); |
|
- | 3343 | ||
- | 3344 | if (wait_for(((pval = vlv_punit_read(dev_priv, PUNIT_REG_GPU_FREQ_STS)) & GENFREQSTATUS) == 0, 10)) |
|
- | 3345 | DRM_DEBUG_DRIVER("timed out waiting for Punit\n"); |
|
- | 3346 | ||
- | 3347 | pval >>= 8; |
|
- | 3348 | ||
- | 3349 | if (pval != dev_priv->rps.cur_delay) |
|
- | 3350 | DRM_DEBUG_DRIVER("Punit overrode GPU freq: %d MHz (%u) requested, but got %d Mhz (%u)\n", |
|
- | 3351 | vlv_gpu_freq(dev_priv->mem_freq, dev_priv->rps.cur_delay), |
|
- | 3352 | dev_priv->rps.cur_delay, |
|
- | 3353 | vlv_gpu_freq(dev_priv->mem_freq, pval), pval); |
|
- | 3354 | ||
- | 3355 | dev_priv->rps.cur_delay = pval; |
|
- | 3356 | } |
|
- | 3357 | ||
- | 3358 | void valleyview_set_rps(struct drm_device *dev, u8 val) |
|
- | 3359 | { |
|
- | 3360 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 3361 | ||
- | 3362 | gen6_rps_limits(dev_priv, &val); |
|
- | 3363 | ||
- | 3364 | WARN_ON(!mutex_is_locked(&dev_priv->rps.hw_lock)); |
|
- | 3365 | WARN_ON(val > dev_priv->rps.max_delay); |
|
- | 3366 | WARN_ON(val < dev_priv->rps.min_delay); |
|
- | 3367 | ||
- | 3368 | vlv_update_rps_cur_delay(dev_priv); |
|
- | 3369 | ||
- | 3370 | DRM_DEBUG_DRIVER("GPU freq request from %d MHz (%u) to %d MHz (%u)\n", |
|
- | 3371 | vlv_gpu_freq(dev_priv->mem_freq, |
|
- | 3372 | dev_priv->rps.cur_delay), |
|
- | 3373 | dev_priv->rps.cur_delay, |
|
- | 3374 | vlv_gpu_freq(dev_priv->mem_freq, val), val); |
|
- | 3375 | ||
- | 3376 | if (val == dev_priv->rps.cur_delay) |
|
- | 3377 | return; |
|
- | 3378 | ||
- | 3379 | vlv_punit_write(dev_priv, PUNIT_REG_GPU_FREQ_REQ, val); |
|
- | 3380 | ||
- | 3381 | dev_priv->rps.cur_delay = val; |
|
- | 3382 | ||
- | 3383 | trace_intel_gpu_freq_change(vlv_gpu_freq(dev_priv->mem_freq, val)); |
|
2503 | } |
3384 | } |
2504 | 3385 | ||
2505 | static void gen6_disable_rps(struct drm_device *dev) |
3386 | static void gen6_disable_rps_interrupts(struct drm_device *dev) |
Line 2506... | Line -... | ||
2506 | { |
- | |
2507 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | |
2508 | 3387 | { |
|
2509 | I915_WRITE(GEN6_RC_CONTROL, 0); |
3388 | struct drm_i915_private *dev_priv = dev->dev_private; |
2510 | I915_WRITE(GEN6_RPNSWREQ, 1 << 31); |
3389 | |
2511 | I915_WRITE(GEN6_PMINTRMSK, 0xffffffff); |
3390 | I915_WRITE(GEN6_PMINTRMSK, 0xffffffff); |
2512 | I915_WRITE(GEN6_PMIER, 0); |
3391 | I915_WRITE(GEN6_PMIER, I915_READ(GEN6_PMIER) & ~GEN6_PM_RPS_EVENTS); |
2513 | /* Complete PM interrupt masking here doesn't race with the rps work |
3392 | /* Complete PM interrupt masking here doesn't race with the rps work |
Line 2514... | Line 3393... | ||
2514 | * item again unmasking PM interrupts because that is using a different |
3393 | * item again unmasking PM interrupts because that is using a different |
2515 | * register (PMIMR) to mask PM interrupts. The only risk is in leaving |
3394 | * register (PMIMR) to mask PM interrupts. The only risk is in leaving |
2516 | * stale bits in PMIIR and PMIMR which gen6_enable_rps will clean up. */ |
3395 | * stale bits in PMIIR and PMIMR which gen6_enable_rps will clean up. */ |
Line 2517... | Line 3396... | ||
2517 | 3396 | ||
- | 3397 | spin_lock_irq(&dev_priv->irq_lock); |
|
- | 3398 | dev_priv->rps.pm_iir = 0; |
|
- | 3399 | spin_unlock_irq(&dev_priv->irq_lock); |
|
- | 3400 | ||
- | 3401 | I915_WRITE(GEN6_PMIIR, GEN6_PM_RPS_EVENTS); |
|
- | 3402 | } |
|
- | 3403 | ||
- | 3404 | static void gen6_disable_rps(struct drm_device *dev) |
|
- | 3405 | { |
|
- | 3406 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 3407 | ||
- | 3408 | I915_WRITE(GEN6_RC_CONTROL, 0); |
|
- | 3409 | I915_WRITE(GEN6_RPNSWREQ, 1 << 31); |
|
- | 3410 | ||
- | 3411 | gen6_disable_rps_interrupts(dev); |
|
- | 3412 | } |
|
- | 3413 | ||
- | 3414 | static void valleyview_disable_rps(struct drm_device *dev) |
|
- | 3415 | { |
|
- | 3416 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 3417 | ||
- | 3418 | I915_WRITE(GEN6_RC_CONTROL, 0); |
|
- | 3419 | ||
- | 3420 | gen6_disable_rps_interrupts(dev); |
|
2518 | spin_lock_irq(&dev_priv->rps.lock); |
3421 | |
Line 2519... | Line 3422... | ||
2519 | dev_priv->rps.pm_iir = 0; |
3422 | if (dev_priv->vlv_pctx) { |
2520 | spin_unlock_irq(&dev_priv->rps.lock); |
3423 | drm_gem_object_unreference(&dev_priv->vlv_pctx->base); |
- | 3424 | dev_priv->vlv_pctx = NULL; |
|
- | 3425 | } |
|
- | 3426 | } |
|
- | 3427 | ||
2521 | 3428 | int intel_enable_rc6(const struct drm_device *dev) |
|
2522 | I915_WRITE(GEN6_PMIIR, I915_READ(GEN6_PMIIR)); |
3429 | { |
2523 | } |
3430 | /* No RC6 before Ironlake */ |
Line 2524... | Line 3431... | ||
2524 | 3431 | if (INTEL_INFO(dev)->gen < 5) |
|
Line 2545... | Line 3452... | ||
2545 | 3452 | ||
2546 | DRM_DEBUG_DRIVER("RC6 and deep RC6 enabled\n"); |
3453 | DRM_DEBUG_DRIVER("RC6 and deep RC6 enabled\n"); |
2547 | return (INTEL_RC6_ENABLE | INTEL_RC6p_ENABLE); |
3454 | return (INTEL_RC6_ENABLE | INTEL_RC6p_ENABLE); |
Line -... | Line 3455... | ||
- | 3455 | } |
|
- | 3456 | ||
- | 3457 | static void gen6_enable_rps_interrupts(struct drm_device *dev) |
|
- | 3458 | { |
|
- | 3459 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 3460 | u32 enabled_intrs; |
|
- | 3461 | ||
- | 3462 | spin_lock_irq(&dev_priv->irq_lock); |
|
- | 3463 | WARN_ON(dev_priv->rps.pm_iir); |
|
- | 3464 | snb_enable_pm_irq(dev_priv, GEN6_PM_RPS_EVENTS); |
|
- | 3465 | I915_WRITE(GEN6_PMIIR, GEN6_PM_RPS_EVENTS); |
|
- | 3466 | spin_unlock_irq(&dev_priv->irq_lock); |
|
- | 3467 | ||
- | 3468 | /* only unmask PM interrupts we need. Mask all others. */ |
|
- | 3469 | enabled_intrs = GEN6_PM_RPS_EVENTS; |
|
- | 3470 | ||
- | 3471 | /* IVB and SNB hard hangs on looping batchbuffer |
|
- | 3472 | * if GEN6_PM_UP_EI_EXPIRED is masked. |
|
- | 3473 | */ |
|
- | 3474 | if (INTEL_INFO(dev)->gen <= 7 && !IS_HASWELL(dev)) |
|
- | 3475 | enabled_intrs |= GEN6_PM_RP_UP_EI_EXPIRED; |
|
- | 3476 | ||
- | 3477 | I915_WRITE(GEN6_PMINTRMSK, ~enabled_intrs); |
|
2548 | } |
3478 | } |
2549 | 3479 | ||
2550 | static void gen6_enable_rps(struct drm_device *dev) |
3480 | static void gen6_enable_rps(struct drm_device *dev) |
2551 | { |
3481 | { |
2552 | struct drm_i915_private *dev_priv = dev->dev_private; |
3482 | struct drm_i915_private *dev_priv = dev->dev_private; |
Line 2596... | Line 3526... | ||
2596 | for_each_ring(ring, dev_priv, i) |
3526 | for_each_ring(ring, dev_priv, i) |
2597 | I915_WRITE(RING_MAX_IDLE(ring->mmio_base), 10); |
3527 | I915_WRITE(RING_MAX_IDLE(ring->mmio_base), 10); |
Line 2598... | Line 3528... | ||
2598 | 3528 | ||
2599 | I915_WRITE(GEN6_RC_SLEEP, 0); |
3529 | I915_WRITE(GEN6_RC_SLEEP, 0); |
- | 3530 | I915_WRITE(GEN6_RC1e_THRESHOLD, 1000); |
|
- | 3531 | if (INTEL_INFO(dev)->gen <= 6 || IS_IVYBRIDGE(dev)) |
|
- | 3532 | I915_WRITE(GEN6_RC6_THRESHOLD, 125000); |
|
2600 | I915_WRITE(GEN6_RC1e_THRESHOLD, 1000); |
3533 | else |
2601 | I915_WRITE(GEN6_RC6_THRESHOLD, 50000); |
3534 | I915_WRITE(GEN6_RC6_THRESHOLD, 50000); |
2602 | I915_WRITE(GEN6_RC6p_THRESHOLD, 150000); |
3535 | I915_WRITE(GEN6_RC6p_THRESHOLD, 150000); |
Line 2603... | Line 3536... | ||
2603 | I915_WRITE(GEN6_RC6pp_THRESHOLD, 64000); /* unused */ |
3536 | I915_WRITE(GEN6_RC6pp_THRESHOLD, 64000); /* unused */ |
Line 2673... | Line 3606... | ||
2673 | DRM_DEBUG_DRIVER("Failed to set the min frequency\n"); |
3606 | DRM_DEBUG_DRIVER("Failed to set the min frequency\n"); |
2674 | } |
3607 | } |
Line 2675... | Line 3608... | ||
2675 | 3608 | ||
Line 2676... | Line -... | ||
2676 | gen6_set_rps(dev_priv->dev, (gt_perf_status & 0xff00) >> 8); |
- | |
2677 | - | ||
2678 | /* requires MSI enabled */ |
- | |
2679 | I915_WRITE(GEN6_PMIER, GEN6_PM_DEFERRED_EVENTS); |
- | |
2680 | spin_lock_irq(&dev_priv->rps.lock); |
- | |
2681 | WARN_ON(dev_priv->rps.pm_iir != 0); |
- | |
2682 | I915_WRITE(GEN6_PMIMR, 0); |
3609 | gen6_set_rps(dev_priv->dev, (gt_perf_status & 0xff00) >> 8); |
2683 | spin_unlock_irq(&dev_priv->rps.lock); |
- | |
Line 2684... | Line 3610... | ||
2684 | /* enable all PM interrupts */ |
3610 | |
2685 | I915_WRITE(GEN6_PMINTRMSK, 0); |
3611 | gen6_enable_rps_interrupts(dev); |
2686 | 3612 | ||
2687 | rc6vids = 0; |
3613 | rc6vids = 0; |
Line 2699... | Line 3625... | ||
2699 | } |
3625 | } |
Line 2700... | Line 3626... | ||
2700 | 3626 | ||
2701 | gen6_gt_force_wake_put(dev_priv); |
3627 | gen6_gt_force_wake_put(dev_priv); |
Line 2702... | Line 3628... | ||
2702 | } |
3628 | } |
2703 | 3629 | ||
2704 | static void gen6_update_ring_freq(struct drm_device *dev) |
3630 | void gen6_update_ring_freq(struct drm_device *dev) |
2705 | { |
3631 | { |
2706 | struct drm_i915_private *dev_priv = dev->dev_private; |
3632 | struct drm_i915_private *dev_priv = dev->dev_private; |
2707 | int min_freq = 15; |
3633 | int min_freq = 15; |
Line 2761... | Line 3687... | ||
2761 | ring_freq << GEN6_PCODE_FREQ_RING_RATIO_SHIFT | |
3687 | ring_freq << GEN6_PCODE_FREQ_RING_RATIO_SHIFT | |
2762 | gpu_freq); |
3688 | gpu_freq); |
2763 | } |
3689 | } |
2764 | } |
3690 | } |
Line -... | Line 3691... | ||
- | 3691 | ||
- | 3692 | int valleyview_rps_max_freq(struct drm_i915_private *dev_priv) |
|
- | 3693 | { |
|
- | 3694 | u32 val, rp0; |
|
- | 3695 | ||
- | 3696 | val = vlv_nc_read(dev_priv, IOSF_NC_FB_GFX_FREQ_FUSE); |
|
- | 3697 | ||
- | 3698 | rp0 = (val & FB_GFX_MAX_FREQ_FUSE_MASK) >> FB_GFX_MAX_FREQ_FUSE_SHIFT; |
|
- | 3699 | /* Clamp to max */ |
|
- | 3700 | rp0 = min_t(u32, rp0, 0xea); |
|
- | 3701 | ||
- | 3702 | return rp0; |
|
- | 3703 | } |
|
- | 3704 | ||
- | 3705 | static int valleyview_rps_rpe_freq(struct drm_i915_private *dev_priv) |
|
- | 3706 | { |
|
- | 3707 | u32 val, rpe; |
|
- | 3708 | ||
- | 3709 | val = vlv_nc_read(dev_priv, IOSF_NC_FB_GFX_FMAX_FUSE_LO); |
|
- | 3710 | rpe = (val & FB_FMAX_VMIN_FREQ_LO_MASK) >> FB_FMAX_VMIN_FREQ_LO_SHIFT; |
|
- | 3711 | val = vlv_nc_read(dev_priv, IOSF_NC_FB_GFX_FMAX_FUSE_HI); |
|
- | 3712 | rpe |= (val & FB_FMAX_VMIN_FREQ_HI_MASK) << 5; |
|
- | 3713 | ||
- | 3714 | return rpe; |
|
- | 3715 | } |
|
- | 3716 | ||
- | 3717 | int valleyview_rps_min_freq(struct drm_i915_private *dev_priv) |
|
- | 3718 | { |
|
- | 3719 | return vlv_punit_read(dev_priv, PUNIT_REG_GPU_LFM) & 0xff; |
|
- | 3720 | } |
|
- | 3721 | ||
- | 3722 | static void vlv_rps_timer_work(struct work_struct *work) |
|
- | 3723 | { |
|
- | 3724 | drm_i915_private_t *dev_priv = container_of(work, drm_i915_private_t, |
|
- | 3725 | rps.vlv_work.work); |
|
- | 3726 | ||
- | 3727 | /* |
|
- | 3728 | * Timer fired, we must be idle. Drop to min voltage state. |
|
- | 3729 | * Note: we use RPe here since it should match the |
|
- | 3730 | * Vmin we were shooting for. That should give us better |
|
- | 3731 | * perf when we come back out of RC6 than if we used the |
|
- | 3732 | * min freq available. |
|
- | 3733 | */ |
|
- | 3734 | mutex_lock(&dev_priv->rps.hw_lock); |
|
- | 3735 | if (dev_priv->rps.cur_delay > dev_priv->rps.rpe_delay) |
|
- | 3736 | valleyview_set_rps(dev_priv->dev, dev_priv->rps.rpe_delay); |
|
- | 3737 | mutex_unlock(&dev_priv->rps.hw_lock); |
|
- | 3738 | } |
|
- | 3739 | ||
- | 3740 | static void valleyview_setup_pctx(struct drm_device *dev) |
|
- | 3741 | { |
|
- | 3742 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 3743 | struct drm_i915_gem_object *pctx; |
|
- | 3744 | unsigned long pctx_paddr; |
|
- | 3745 | u32 pcbr; |
|
- | 3746 | int pctx_size = 24*1024; |
|
- | 3747 | ||
- | 3748 | pcbr = I915_READ(VLV_PCBR); |
|
- | 3749 | if (pcbr) { |
|
- | 3750 | /* BIOS set it up already, grab the pre-alloc'd space */ |
|
- | 3751 | int pcbr_offset; |
|
- | 3752 | ||
- | 3753 | pcbr_offset = (pcbr & (~4095)) - dev_priv->mm.stolen_base; |
|
- | 3754 | pctx = i915_gem_object_create_stolen_for_preallocated(dev_priv->dev, |
|
- | 3755 | pcbr_offset, |
|
- | 3756 | I915_GTT_OFFSET_NONE, |
|
- | 3757 | pctx_size); |
|
- | 3758 | goto out; |
|
- | 3759 | } |
|
- | 3760 | ||
- | 3761 | /* |
|
- | 3762 | * From the Gunit register HAS: |
|
- | 3763 | * The Gfx driver is expected to program this register and ensure |
|
- | 3764 | * proper allocation within Gfx stolen memory. For example, this |
|
- | 3765 | * register should be programmed such than the PCBR range does not |
|
- | 3766 | * overlap with other ranges, such as the frame buffer, protected |
|
- | 3767 | * memory, or any other relevant ranges. |
|
- | 3768 | */ |
|
- | 3769 | pctx = i915_gem_object_create_stolen(dev, pctx_size); |
|
- | 3770 | if (!pctx) { |
|
- | 3771 | DRM_DEBUG("not enough stolen space for PCTX, disabling\n"); |
|
- | 3772 | return; |
|
- | 3773 | } |
|
- | 3774 | ||
- | 3775 | pctx_paddr = dev_priv->mm.stolen_base + pctx->stolen->start; |
|
- | 3776 | I915_WRITE(VLV_PCBR, pctx_paddr); |
|
- | 3777 | ||
- | 3778 | out: |
|
- | 3779 | dev_priv->vlv_pctx = pctx; |
|
- | 3780 | } |
|
- | 3781 | ||
- | 3782 | static void valleyview_enable_rps(struct drm_device *dev) |
|
- | 3783 | { |
|
- | 3784 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 3785 | struct intel_ring_buffer *ring; |
|
- | 3786 | u32 gtfifodbg, val; |
|
- | 3787 | int i; |
|
- | 3788 | ||
- | 3789 | WARN_ON(!mutex_is_locked(&dev_priv->rps.hw_lock)); |
|
- | 3790 | ||
- | 3791 | if ((gtfifodbg = I915_READ(GTFIFODBG))) { |
|
- | 3792 | DRM_ERROR("GT fifo had a previous error %x\n", gtfifodbg); |
|
- | 3793 | I915_WRITE(GTFIFODBG, gtfifodbg); |
|
- | 3794 | } |
|
- | 3795 | ||
- | 3796 | valleyview_setup_pctx(dev); |
|
- | 3797 | ||
- | 3798 | gen6_gt_force_wake_get(dev_priv); |
|
- | 3799 | ||
- | 3800 | I915_WRITE(GEN6_RP_UP_THRESHOLD, 59400); |
|
- | 3801 | I915_WRITE(GEN6_RP_DOWN_THRESHOLD, 245000); |
|
- | 3802 | I915_WRITE(GEN6_RP_UP_EI, 66000); |
|
- | 3803 | I915_WRITE(GEN6_RP_DOWN_EI, 350000); |
|
- | 3804 | ||
- | 3805 | I915_WRITE(GEN6_RP_IDLE_HYSTERSIS, 10); |
|
- | 3806 | ||
- | 3807 | I915_WRITE(GEN6_RP_CONTROL, |
|
- | 3808 | GEN6_RP_MEDIA_TURBO | |
|
- | 3809 | GEN6_RP_MEDIA_HW_NORMAL_MODE | |
|
- | 3810 | GEN6_RP_MEDIA_IS_GFX | |
|
- | 3811 | GEN6_RP_ENABLE | |
|
- | 3812 | GEN6_RP_UP_BUSY_AVG | |
|
- | 3813 | GEN6_RP_DOWN_IDLE_CONT); |
|
- | 3814 | ||
- | 3815 | I915_WRITE(GEN6_RC6_WAKE_RATE_LIMIT, 0x00280000); |
|
- | 3816 | I915_WRITE(GEN6_RC_EVALUATION_INTERVAL, 125000); |
|
- | 3817 | I915_WRITE(GEN6_RC_IDLE_HYSTERSIS, 25); |
|
- | 3818 | ||
- | 3819 | for_each_ring(ring, dev_priv, i) |
|
- | 3820 | I915_WRITE(RING_MAX_IDLE(ring->mmio_base), 10); |
|
- | 3821 | ||
- | 3822 | I915_WRITE(GEN6_RC6_THRESHOLD, 0xc350); |
|
- | 3823 | ||
- | 3824 | /* allows RC6 residency counter to work */ |
|
- | 3825 | I915_WRITE(0x138104, _MASKED_BIT_ENABLE(0x3)); |
|
- | 3826 | I915_WRITE(GEN6_RC_CONTROL, |
|
- | 3827 | GEN7_RC_CTL_TO_MODE); |
|
- | 3828 | ||
- | 3829 | val = vlv_punit_read(dev_priv, PUNIT_REG_GPU_FREQ_STS); |
|
- | 3830 | switch ((val >> 6) & 3) { |
|
- | 3831 | case 0: |
|
- | 3832 | case 1: |
|
- | 3833 | dev_priv->mem_freq = 800; |
|
- | 3834 | break; |
|
- | 3835 | case 2: |
|
- | 3836 | dev_priv->mem_freq = 1066; |
|
- | 3837 | break; |
|
- | 3838 | case 3: |
|
- | 3839 | dev_priv->mem_freq = 1333; |
|
- | 3840 | break; |
|
- | 3841 | } |
|
- | 3842 | DRM_DEBUG_DRIVER("DDR speed: %d MHz", dev_priv->mem_freq); |
|
- | 3843 | ||
- | 3844 | DRM_DEBUG_DRIVER("GPLL enabled? %s\n", val & 0x10 ? "yes" : "no"); |
|
- | 3845 | DRM_DEBUG_DRIVER("GPU status: 0x%08x\n", val); |
|
- | 3846 | ||
- | 3847 | dev_priv->rps.cur_delay = (val >> 8) & 0xff; |
|
- | 3848 | DRM_DEBUG_DRIVER("current GPU freq: %d MHz (%u)\n", |
|
- | 3849 | vlv_gpu_freq(dev_priv->mem_freq, |
|
- | 3850 | dev_priv->rps.cur_delay), |
|
- | 3851 | dev_priv->rps.cur_delay); |
|
- | 3852 | ||
- | 3853 | dev_priv->rps.max_delay = valleyview_rps_max_freq(dev_priv); |
|
- | 3854 | dev_priv->rps.hw_max = dev_priv->rps.max_delay; |
|
- | 3855 | DRM_DEBUG_DRIVER("max GPU freq: %d MHz (%u)\n", |
|
- | 3856 | vlv_gpu_freq(dev_priv->mem_freq, |
|
- | 3857 | dev_priv->rps.max_delay), |
|
- | 3858 | dev_priv->rps.max_delay); |
|
- | 3859 | ||
- | 3860 | dev_priv->rps.rpe_delay = valleyview_rps_rpe_freq(dev_priv); |
|
- | 3861 | DRM_DEBUG_DRIVER("RPe GPU freq: %d MHz (%u)\n", |
|
- | 3862 | vlv_gpu_freq(dev_priv->mem_freq, |
|
- | 3863 | dev_priv->rps.rpe_delay), |
|
- | 3864 | dev_priv->rps.rpe_delay); |
|
- | 3865 | ||
- | 3866 | dev_priv->rps.min_delay = valleyview_rps_min_freq(dev_priv); |
|
- | 3867 | DRM_DEBUG_DRIVER("min GPU freq: %d MHz (%u)\n", |
|
- | 3868 | vlv_gpu_freq(dev_priv->mem_freq, |
|
- | 3869 | dev_priv->rps.min_delay), |
|
- | 3870 | dev_priv->rps.min_delay); |
|
- | 3871 | ||
- | 3872 | DRM_DEBUG_DRIVER("setting GPU freq to %d MHz (%u)\n", |
|
- | 3873 | vlv_gpu_freq(dev_priv->mem_freq, |
|
- | 3874 | dev_priv->rps.rpe_delay), |
|
- | 3875 | dev_priv->rps.rpe_delay); |
|
- | 3876 | ||
- | 3877 | valleyview_set_rps(dev_priv->dev, dev_priv->rps.rpe_delay); |
|
- | 3878 | ||
- | 3879 | gen6_enable_rps_interrupts(dev); |
|
- | 3880 | ||
- | 3881 | gen6_gt_force_wake_put(dev_priv); |
|
- | 3882 | } |
|
2765 | 3883 | ||
2766 | void ironlake_teardown_rc6(struct drm_device *dev) |
3884 | void ironlake_teardown_rc6(struct drm_device *dev) |
2767 | { |
3885 | { |
Line 2768... | Line 3886... | ||
2768 | struct drm_i915_private *dev_priv = dev->dev_private; |
3886 | struct drm_i915_private *dev_priv = dev->dev_private; |
Line 2850... | Line 3968... | ||
2850 | return; |
3968 | return; |
2851 | } |
3969 | } |
Line 2852... | Line 3970... | ||
2852 | 3970 | ||
2853 | intel_ring_emit(ring, MI_SUSPEND_FLUSH | MI_SUSPEND_FLUSH_EN); |
3971 | intel_ring_emit(ring, MI_SUSPEND_FLUSH | MI_SUSPEND_FLUSH_EN); |
2854 | intel_ring_emit(ring, MI_SET_CONTEXT); |
3972 | intel_ring_emit(ring, MI_SET_CONTEXT); |
2855 | intel_ring_emit(ring, dev_priv->ips.renderctx->gtt_offset | |
3973 | intel_ring_emit(ring, i915_gem_obj_ggtt_offset(dev_priv->ips.renderctx) | |
2856 | MI_MM_SPACE_GTT | |
3974 | MI_MM_SPACE_GTT | |
2857 | MI_SAVE_EXT_STATE_EN | |
3975 | MI_SAVE_EXT_STATE_EN | |
2858 | MI_RESTORE_EXT_STATE_EN | |
3976 | MI_RESTORE_EXT_STATE_EN | |
2859 | MI_RESTORE_INHIBIT); |
3977 | MI_RESTORE_INHIBIT); |
Line 2873... | Line 3991... | ||
2873 | DRM_ERROR("failed to enable ironlake power savings\n"); |
3991 | DRM_ERROR("failed to enable ironlake power savings\n"); |
2874 | ironlake_teardown_rc6(dev); |
3992 | ironlake_teardown_rc6(dev); |
2875 | return; |
3993 | return; |
2876 | } |
3994 | } |
Line 2877... | Line 3995... | ||
2877 | 3995 | ||
2878 | I915_WRITE(PWRCTXA, dev_priv->ips.pwrctx->gtt_offset | PWRCTX_EN); |
3996 | I915_WRITE(PWRCTXA, i915_gem_obj_ggtt_offset(dev_priv->ips.pwrctx) | PWRCTX_EN); |
2879 | I915_WRITE(RSTDBYCTL, I915_READ(RSTDBYCTL) & ~RCX_SW_EXIT); |
3997 | I915_WRITE(RSTDBYCTL, I915_READ(RSTDBYCTL) & ~RCX_SW_EXIT); |
Line 2880... | Line 3998... | ||
2880 | } |
3998 | } |
2881 | 3999 | ||
Line 3484... | Line 4602... | ||
3484 | 4602 | ||
3485 | void intel_disable_gt_powersave(struct drm_device *dev) |
4603 | void intel_disable_gt_powersave(struct drm_device *dev) |
3486 | { |
4604 | { |
Line -... | Line 4605... | ||
- | 4605 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 4606 | ||
- | 4607 | /* Interrupts should be disabled already to avoid re-arming. */ |
|
3487 | struct drm_i915_private *dev_priv = dev->dev_private; |
4608 | WARN_ON(dev->irq_enabled); |
3488 | 4609 | ||
3489 | if (IS_IRONLAKE_M(dev)) { |
4610 | if (IS_IRONLAKE_M(dev)) { |
3490 | ironlake_disable_drps(dev); |
4611 | ironlake_disable_drps(dev); |
3491 | ironlake_disable_rc6(dev); |
4612 | ironlake_disable_rc6(dev); |
3492 | } else if (INTEL_INFO(dev)->gen >= 6 && !IS_VALLEYVIEW(dev)) { |
4613 | } else if (INTEL_INFO(dev)->gen >= 6 && !IS_VALLEYVIEW(dev)) { |
- | 4614 | // cancel_delayed_work_sync(&dev_priv->rps.delayed_resume_work); |
|
- | 4615 | mutex_lock(&dev_priv->rps.hw_lock); |
|
- | 4616 | if (IS_VALLEYVIEW(dev)) |
|
3493 | // cancel_delayed_work_sync(&dev_priv->rps.delayed_resume_work); |
4617 | valleyview_disable_rps(dev); |
3494 | mutex_lock(&dev_priv->rps.hw_lock); |
4618 | else |
3495 | gen6_disable_rps(dev); |
4619 | gen6_disable_rps(dev); |
3496 | mutex_unlock(&dev_priv->rps.hw_lock); |
4620 | mutex_unlock(&dev_priv->rps.hw_lock); |
Line 3505... | Line 4629... | ||
3505 | struct drm_device *dev = dev_priv->dev; |
4629 | struct drm_device *dev = dev_priv->dev; |
Line 3506... | Line 4630... | ||
3506 | 4630 | ||
Line 3507... | Line 4631... | ||
3507 | ENTER(); |
4631 | ENTER(); |
- | 4632 | ||
- | 4633 | mutex_lock(&dev_priv->rps.hw_lock); |
|
- | 4634 | ||
- | 4635 | if (IS_VALLEYVIEW(dev)) { |
|
3508 | 4636 | valleyview_enable_rps(dev); |
|
3509 | mutex_lock(&dev_priv->rps.hw_lock); |
4637 | } else { |
- | 4638 | gen6_enable_rps(dev); |
|
3510 | gen6_enable_rps(dev); |
4639 | gen6_update_ring_freq(dev); |
Line 3511... | Line 4640... | ||
3511 | gen6_update_ring_freq(dev); |
4640 | } |
3512 | mutex_unlock(&dev_priv->rps.hw_lock); |
4641 | mutex_unlock(&dev_priv->rps.hw_lock); |
Line 3520... | Line 4649... | ||
3520 | 4649 | ||
3521 | if (IS_IRONLAKE_M(dev)) { |
4650 | if (IS_IRONLAKE_M(dev)) { |
3522 | ironlake_enable_drps(dev); |
4651 | ironlake_enable_drps(dev); |
3523 | ironlake_enable_rc6(dev); |
4652 | ironlake_enable_rc6(dev); |
3524 | intel_init_emon(dev); |
4653 | intel_init_emon(dev); |
3525 | } else if ((IS_GEN6(dev) || IS_GEN7(dev)) && !IS_VALLEYVIEW(dev)) { |
4654 | } else if (IS_GEN6(dev) || IS_GEN7(dev)) { |
3526 | /* |
4655 | /* |
3527 | * PCU communication is slow and this doesn't need to be |
4656 | * PCU communication is slow and this doesn't need to be |
3528 | * done at any specific time, so do this out of our fast path |
4657 | * done at any specific time, so do this out of our fast path |
3529 | * to make resume and init faster. |
4658 | * to make resume and init faster. |
Line 3543... | Line 4672... | ||
3543 | * start up when no ports are active. |
4672 | * start up when no ports are active. |
3544 | */ |
4673 | */ |
3545 | I915_WRITE(SOUTH_DSPCLK_GATE_D, PCH_DPLSUNIT_CLOCK_GATE_DISABLE); |
4674 | I915_WRITE(SOUTH_DSPCLK_GATE_D, PCH_DPLSUNIT_CLOCK_GATE_DISABLE); |
3546 | } |
4675 | } |
Line -... | Line 4676... | ||
- | 4676 | ||
- | 4677 | static void g4x_disable_trickle_feed(struct drm_device *dev) |
|
- | 4678 | { |
|
- | 4679 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 4680 | int pipe; |
|
- | 4681 | ||
- | 4682 | for_each_pipe(pipe) { |
|
- | 4683 | I915_WRITE(DSPCNTR(pipe), |
|
- | 4684 | I915_READ(DSPCNTR(pipe)) | |
|
- | 4685 | DISPPLANE_TRICKLE_FEED_DISABLE); |
|
- | 4686 | intel_flush_display_plane(dev_priv, pipe); |
|
- | 4687 | } |
|
- | 4688 | } |
|
3547 | 4689 | ||
3548 | static void ironlake_init_clock_gating(struct drm_device *dev) |
4690 | static void ironlake_init_clock_gating(struct drm_device *dev) |
3549 | { |
4691 | { |
3550 | struct drm_i915_private *dev_priv = dev->dev_private; |
4692 | struct drm_i915_private *dev_priv = dev->dev_private; |
Line -... | Line 4693... | ||
- | 4693 | uint32_t dspclk_gate = ILK_VRHUNIT_CLOCK_GATE_DISABLE; |
|
3551 | uint32_t dspclk_gate = ILK_VRHUNIT_CLOCK_GATE_DISABLE; |
4694 | |
- | 4695 | /* |
|
- | 4696 | * Required for FBC |
|
3552 | 4697 | * WaFbcDisableDpfcClockGating:ilk |
|
3553 | /* Required for FBC */ |
4698 | */ |
3554 | dspclk_gate |= ILK_DPFCRUNIT_CLOCK_GATE_DISABLE | |
4699 | dspclk_gate |= ILK_DPFCRUNIT_CLOCK_GATE_DISABLE | |
Line 3555... | Line 4700... | ||
3555 | ILK_DPFCUNIT_CLOCK_GATE_DISABLE | |
4700 | ILK_DPFCUNIT_CLOCK_GATE_DISABLE | |
Line 3585... | Line 4730... | ||
3585 | * The bit 22 of 0x42000 |
4730 | * The bit 22 of 0x42000 |
3586 | * The bit 22 of 0x42004 |
4731 | * The bit 22 of 0x42004 |
3587 | * The bit 7,8,9 of 0x42020. |
4732 | * The bit 7,8,9 of 0x42020. |
3588 | */ |
4733 | */ |
3589 | if (IS_IRONLAKE_M(dev)) { |
4734 | if (IS_IRONLAKE_M(dev)) { |
- | 4735 | /* WaFbcAsynchFlipDisableFbcQueue:ilk */ |
|
3590 | I915_WRITE(ILK_DISPLAY_CHICKEN1, |
4736 | I915_WRITE(ILK_DISPLAY_CHICKEN1, |
3591 | I915_READ(ILK_DISPLAY_CHICKEN1) | |
4737 | I915_READ(ILK_DISPLAY_CHICKEN1) | |
3592 | ILK_FBCQ_DIS); |
4738 | ILK_FBCQ_DIS); |
3593 | I915_WRITE(ILK_DISPLAY_CHICKEN2, |
4739 | I915_WRITE(ILK_DISPLAY_CHICKEN2, |
3594 | I915_READ(ILK_DISPLAY_CHICKEN2) | |
4740 | I915_READ(ILK_DISPLAY_CHICKEN2) | |
Line 3602... | Line 4748... | ||
3602 | ILK_ELPIN_409_SELECT); |
4748 | ILK_ELPIN_409_SELECT); |
3603 | I915_WRITE(_3D_CHICKEN2, |
4749 | I915_WRITE(_3D_CHICKEN2, |
3604 | _3D_CHICKEN2_WM_READ_PIPELINED << 16 | |
4750 | _3D_CHICKEN2_WM_READ_PIPELINED << 16 | |
3605 | _3D_CHICKEN2_WM_READ_PIPELINED); |
4751 | _3D_CHICKEN2_WM_READ_PIPELINED); |
Line 3606... | Line 4752... | ||
3606 | 4752 | ||
3607 | /* WaDisableRenderCachePipelinedFlush */ |
4753 | /* WaDisableRenderCachePipelinedFlush:ilk */ |
3608 | I915_WRITE(CACHE_MODE_0, |
4754 | I915_WRITE(CACHE_MODE_0, |
Line -... | Line 4755... | ||
- | 4755 | _MASKED_BIT_ENABLE(CM0_PIPELINED_RENDER_FLUSH_DISABLE)); |
|
- | 4756 | ||
3609 | _MASKED_BIT_ENABLE(CM0_PIPELINED_RENDER_FLUSH_DISABLE)); |
4757 | g4x_disable_trickle_feed(dev); |
3610 | 4758 | ||
Line 3611... | Line 4759... | ||
3611 | ibx_init_clock_gating(dev); |
4759 | ibx_init_clock_gating(dev); |
3612 | } |
4760 | } |
Line 3630... | Line 4778... | ||
3630 | */ |
4778 | */ |
3631 | for_each_pipe(pipe) { |
4779 | for_each_pipe(pipe) { |
3632 | val = I915_READ(TRANS_CHICKEN2(pipe)); |
4780 | val = I915_READ(TRANS_CHICKEN2(pipe)); |
3633 | val |= TRANS_CHICKEN2_TIMING_OVERRIDE; |
4781 | val |= TRANS_CHICKEN2_TIMING_OVERRIDE; |
3634 | val &= ~TRANS_CHICKEN2_FDI_POLARITY_REVERSED; |
4782 | val &= ~TRANS_CHICKEN2_FDI_POLARITY_REVERSED; |
3635 | if (dev_priv->fdi_rx_polarity_inverted) |
4783 | if (dev_priv->vbt.fdi_rx_polarity_inverted) |
3636 | val |= TRANS_CHICKEN2_FDI_POLARITY_REVERSED; |
4784 | val |= TRANS_CHICKEN2_FDI_POLARITY_REVERSED; |
3637 | val &= ~TRANS_CHICKEN2_FRAME_START_DELAY_MASK; |
4785 | val &= ~TRANS_CHICKEN2_FRAME_START_DELAY_MASK; |
3638 | val &= ~TRANS_CHICKEN2_DISABLE_DEEP_COLOR_COUNTER; |
4786 | val &= ~TRANS_CHICKEN2_DISABLE_DEEP_COLOR_COUNTER; |
3639 | val &= ~TRANS_CHICKEN2_DISABLE_DEEP_COLOR_MODESWITCH; |
4787 | val &= ~TRANS_CHICKEN2_DISABLE_DEEP_COLOR_MODESWITCH; |
3640 | I915_WRITE(TRANS_CHICKEN2(pipe), val); |
4788 | I915_WRITE(TRANS_CHICKEN2(pipe), val); |
Line 3660... | Line 4808... | ||
3660 | } |
4808 | } |
Line 3661... | Line 4809... | ||
3661 | 4809 | ||
3662 | static void gen6_init_clock_gating(struct drm_device *dev) |
4810 | static void gen6_init_clock_gating(struct drm_device *dev) |
3663 | { |
4811 | { |
3664 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | |
3665 | int pipe; |
4812 | struct drm_i915_private *dev_priv = dev->dev_private; |
Line 3666... | Line 4813... | ||
3666 | uint32_t dspclk_gate = ILK_VRHUNIT_CLOCK_GATE_DISABLE; |
4813 | uint32_t dspclk_gate = ILK_VRHUNIT_CLOCK_GATE_DISABLE; |
Line 3667... | Line 4814... | ||
3667 | 4814 | ||
3668 | I915_WRITE(ILK_DSPCLK_GATE_D, dspclk_gate); |
4815 | I915_WRITE(ILK_DSPCLK_GATE_D, dspclk_gate); |
3669 | 4816 | ||
Line 3670... | Line 4817... | ||
3670 | I915_WRITE(ILK_DISPLAY_CHICKEN2, |
4817 | I915_WRITE(ILK_DISPLAY_CHICKEN2, |
3671 | I915_READ(ILK_DISPLAY_CHICKEN2) | |
4818 | I915_READ(ILK_DISPLAY_CHICKEN2) | |
3672 | ILK_ELPIN_409_SELECT); |
4819 | ILK_ELPIN_409_SELECT); |
Line 3673... | Line 4820... | ||
3673 | 4820 | ||
3674 | /* WaDisableHiZPlanesWhenMSAAEnabled */ |
4821 | /* WaDisableHiZPlanesWhenMSAAEnabled:snb */ |
3675 | I915_WRITE(_3D_CHICKEN, |
4822 | I915_WRITE(_3D_CHICKEN, |
3676 | _MASKED_BIT_ENABLE(_3D_CHICKEN_HIZ_PLANE_DISABLE_MSAA_4X_SNB)); |
4823 | _MASKED_BIT_ENABLE(_3D_CHICKEN_HIZ_PLANE_DISABLE_MSAA_4X_SNB)); |
Line 3677... | Line 4824... | ||
3677 | 4824 | ||
Line 3700... | Line 4847... | ||
3700 | * alpha test or pixel discard. |
4847 | * alpha test or pixel discard. |
3701 | * |
4848 | * |
3702 | * According to the spec, bit 11 (RCCUNIT) must also be set, |
4849 | * According to the spec, bit 11 (RCCUNIT) must also be set, |
3703 | * but we didn't debug actual testcases to find it out. |
4850 | * but we didn't debug actual testcases to find it out. |
3704 | * |
4851 | * |
3705 | * Also apply WaDisableVDSUnitClockGating and |
4852 | * Also apply WaDisableVDSUnitClockGating:snb and |
3706 | * WaDisableRCPBUnitClockGating. |
4853 | * WaDisableRCPBUnitClockGating:snb. |
3707 | */ |
4854 | */ |
3708 | I915_WRITE(GEN6_UCGCTL2, |
4855 | I915_WRITE(GEN6_UCGCTL2, |
3709 | GEN7_VDSUNIT_CLOCK_GATE_DISABLE | |
4856 | GEN7_VDSUNIT_CLOCK_GATE_DISABLE | |
3710 | GEN6_RCPBUNIT_CLOCK_GATE_DISABLE | |
4857 | GEN6_RCPBUNIT_CLOCK_GATE_DISABLE | |
3711 | GEN6_RCCUNIT_CLOCK_GATE_DISABLE); |
4858 | GEN6_RCCUNIT_CLOCK_GATE_DISABLE); |
Line 3720... | Line 4867... | ||
3720 | * The bit21 and bit22 of 0x42000 |
4867 | * The bit21 and bit22 of 0x42000 |
3721 | * The bit21 and bit22 of 0x42004 |
4868 | * The bit21 and bit22 of 0x42004 |
3722 | * The bit5 and bit7 of 0x42020 |
4869 | * The bit5 and bit7 of 0x42020 |
3723 | * The bit14 of 0x70180 |
4870 | * The bit14 of 0x70180 |
3724 | * The bit14 of 0x71180 |
4871 | * The bit14 of 0x71180 |
- | 4872 | * |
|
- | 4873 | * WaFbcAsynchFlipDisableFbcQueue:snb |
|
3725 | */ |
4874 | */ |
3726 | I915_WRITE(ILK_DISPLAY_CHICKEN1, |
4875 | I915_WRITE(ILK_DISPLAY_CHICKEN1, |
3727 | I915_READ(ILK_DISPLAY_CHICKEN1) | |
4876 | I915_READ(ILK_DISPLAY_CHICKEN1) | |
3728 | ILK_FBCQ_DIS | ILK_PABSTRETCH_DIS); |
4877 | ILK_FBCQ_DIS | ILK_PABSTRETCH_DIS); |
3729 | I915_WRITE(ILK_DISPLAY_CHICKEN2, |
4878 | I915_WRITE(ILK_DISPLAY_CHICKEN2, |
Line 3732... | Line 4881... | ||
3732 | I915_WRITE(ILK_DSPCLK_GATE_D, |
4881 | I915_WRITE(ILK_DSPCLK_GATE_D, |
3733 | I915_READ(ILK_DSPCLK_GATE_D) | |
4882 | I915_READ(ILK_DSPCLK_GATE_D) | |
3734 | ILK_DPARBUNIT_CLOCK_GATE_ENABLE | |
4883 | ILK_DPARBUNIT_CLOCK_GATE_ENABLE | |
3735 | ILK_DPFDUNIT_CLOCK_GATE_ENABLE); |
4884 | ILK_DPFDUNIT_CLOCK_GATE_ENABLE); |
Line 3736... | Line -... | ||
3736 | - | ||
3737 | /* WaMbcDriverBootEnable */ |
- | |
3738 | I915_WRITE(GEN6_MBCTL, I915_READ(GEN6_MBCTL) | |
- | |
3739 | GEN6_MBCTL_ENABLE_BOOT_FETCH); |
- | |
3740 | 4885 | ||
3741 | for_each_pipe(pipe) { |
- | |
3742 | I915_WRITE(DSPCNTR(pipe), |
- | |
3743 | I915_READ(DSPCNTR(pipe)) | |
- | |
3744 | DISPPLANE_TRICKLE_FEED_DISABLE); |
- | |
3745 | intel_flush_display_plane(dev_priv, pipe); |
- | |
Line 3746... | Line 4886... | ||
3746 | } |
4886 | g4x_disable_trickle_feed(dev); |
3747 | 4887 | ||
3748 | /* The default value should be 0x200 according to docs, but the two |
4888 | /* The default value should be 0x200 according to docs, but the two |
3749 | * platforms I checked have a 0 for this. (Maybe BIOS overrides?) */ |
4889 | * platforms I checked have a 0 for this. (Maybe BIOS overrides?) */ |
Line 3762... | Line 4902... | ||
3762 | reg &= ~GEN7_FF_SCHED_MASK; |
4902 | reg &= ~GEN7_FF_SCHED_MASK; |
3763 | reg |= GEN7_FF_TS_SCHED_HW; |
4903 | reg |= GEN7_FF_TS_SCHED_HW; |
3764 | reg |= GEN7_FF_VS_SCHED_HW; |
4904 | reg |= GEN7_FF_VS_SCHED_HW; |
3765 | reg |= GEN7_FF_DS_SCHED_HW; |
4905 | reg |= GEN7_FF_DS_SCHED_HW; |
Line 3766... | Line -... | ||
3766 | - | ||
3767 | /* WaVSRefCountFullforceMissDisable */ |
4906 | |
3768 | if (IS_HASWELL(dev_priv->dev)) |
4907 | if (IS_HASWELL(dev_priv->dev)) |
Line 3769... | Line 4908... | ||
3769 | reg &= ~GEN7_FF_VS_REF_CNT_FFME; |
4908 | reg &= ~GEN7_FF_VS_REF_CNT_FFME; |
3770 | 4909 | ||
Line 3781... | Line 4920... | ||
3781 | */ |
4920 | */ |
3782 | if (dev_priv->pch_id == INTEL_PCH_LPT_LP_DEVICE_ID_TYPE) |
4921 | if (dev_priv->pch_id == INTEL_PCH_LPT_LP_DEVICE_ID_TYPE) |
3783 | I915_WRITE(SOUTH_DSPCLK_GATE_D, |
4922 | I915_WRITE(SOUTH_DSPCLK_GATE_D, |
3784 | I915_READ(SOUTH_DSPCLK_GATE_D) | |
4923 | I915_READ(SOUTH_DSPCLK_GATE_D) | |
3785 | PCH_LP_PARTITION_LEVEL_DISABLE); |
4924 | PCH_LP_PARTITION_LEVEL_DISABLE); |
- | 4925 | ||
- | 4926 | /* WADPOClockGatingDisable:hsw */ |
|
- | 4927 | I915_WRITE(_TRANSA_CHICKEN1, |
|
- | 4928 | I915_READ(_TRANSA_CHICKEN1) | |
|
- | 4929 | TRANS_CHICKEN1_DP0UNIT_GC_DISABLE); |
|
- | 4930 | } |
|
- | 4931 | ||
- | 4932 | static void lpt_suspend_hw(struct drm_device *dev) |
|
- | 4933 | { |
|
- | 4934 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 4935 | ||
- | 4936 | if (dev_priv->pch_id == INTEL_PCH_LPT_LP_DEVICE_ID_TYPE) { |
|
- | 4937 | uint32_t val = I915_READ(SOUTH_DSPCLK_GATE_D); |
|
- | 4938 | ||
- | 4939 | val &= ~PCH_LP_PARTITION_LEVEL_DISABLE; |
|
- | 4940 | I915_WRITE(SOUTH_DSPCLK_GATE_D, val); |
|
- | 4941 | } |
|
3786 | } |
4942 | } |
Line 3787... | Line 4943... | ||
3787 | 4943 | ||
3788 | static void haswell_init_clock_gating(struct drm_device *dev) |
4944 | static void haswell_init_clock_gating(struct drm_device *dev) |
3789 | { |
4945 | { |
3790 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | |
Line 3791... | Line 4946... | ||
3791 | int pipe; |
4946 | struct drm_i915_private *dev_priv = dev->dev_private; |
3792 | 4947 | ||
3793 | I915_WRITE(WM3_LP_ILK, 0); |
4948 | I915_WRITE(WM3_LP_ILK, 0); |
Line 3794... | Line 4949... | ||
3794 | I915_WRITE(WM2_LP_ILK, 0); |
4949 | I915_WRITE(WM2_LP_ILK, 0); |
3795 | I915_WRITE(WM1_LP_ILK, 0); |
4950 | I915_WRITE(WM1_LP_ILK, 0); |
3796 | 4951 | ||
3797 | /* According to the spec, bit 13 (RCZUNIT) must be set on IVB. |
4952 | /* According to the spec, bit 13 (RCZUNIT) must be set on IVB. |
Line 3798... | Line 4953... | ||
3798 | * This implements the WaDisableRCZUnitClockGating workaround. |
4953 | * This implements the WaDisableRCZUnitClockGating:hsw workaround. |
3799 | */ |
4954 | */ |
3800 | I915_WRITE(GEN6_UCGCTL2, GEN6_RCZUNIT_CLOCK_GATE_DISABLE); |
4955 | I915_WRITE(GEN6_UCGCTL2, GEN6_RCZUNIT_CLOCK_GATE_DISABLE); |
Line 3801... | Line 4956... | ||
3801 | 4956 | ||
3802 | /* Apply the WaDisableRHWOOptimizationForRenderHang workaround. */ |
4957 | /* Apply the WaDisableRHWOOptimizationForRenderHang:hsw workaround. */ |
3803 | I915_WRITE(GEN7_COMMON_SLICE_CHICKEN1, |
4958 | I915_WRITE(GEN7_COMMON_SLICE_CHICKEN1, |
3804 | GEN7_CSC1_RHWO_OPT_DISABLE_IN_RCC); |
4959 | GEN7_CSC1_RHWO_OPT_DISABLE_IN_RCC); |
3805 | 4960 | ||
Line -... | Line 4961... | ||
- | 4961 | /* WaApplyL3ControlAndL3ChickenMode:hsw */ |
|
- | 4962 | I915_WRITE(GEN7_L3CNTLREG1, |
|
- | 4963 | GEN7_WA_FOR_GEN7_L3_CONTROL); |
|
- | 4964 | I915_WRITE(GEN7_L3_CHICKEN_MODE_REGISTER, |
|
- | 4965 | GEN7_WA_L3_CHICKEN_MODE); |
|
3806 | /* WaApplyL3ControlAndL3ChickenMode requires those two on Ivy Bridge */ |
4966 | |
3807 | I915_WRITE(GEN7_L3CNTLREG1, |
4967 | /* L3 caching of data atomics doesn't work -- disable it. */ |
3808 | GEN7_WA_FOR_GEN7_L3_CONTROL); |
4968 | I915_WRITE(HSW_SCRATCH1, HSW_SCRATCH1_L3_DATA_ATOMICS_DISABLE); |
3809 | I915_WRITE(GEN7_L3_CHICKEN_MODE_REGISTER, |
4969 | I915_WRITE(HSW_ROW_CHICKEN3, |
Line 3810... | Line -... | ||
3810 | GEN7_WA_L3_CHICKEN_MODE); |
- | |
3811 | - | ||
3812 | /* This is required by WaCatErrorRejectionIssue */ |
- | |
3813 | I915_WRITE(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG, |
- | |
3814 | I915_READ(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) | |
4970 | _MASKED_BIT_ENABLE(HSW_ROW_CHICKEN3_L3_GLOBAL_ATOMICS_DISABLE)); |
3815 | GEN7_SQ_CHICKEN_MBCUNIT_SQINTMOB); |
- | |
3816 | - | ||
3817 | for_each_pipe(pipe) { |
4971 | |
Line 3818... | Line 4972... | ||
3818 | I915_WRITE(DSPCNTR(pipe), |
4972 | /* This is required by WaCatErrorRejectionIssue:hsw */ |
3819 | I915_READ(DSPCNTR(pipe)) | |
4973 | I915_WRITE(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG, |
3820 | DISPPLANE_TRICKLE_FEED_DISABLE); |
4974 | I915_READ(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) | |
Line 3821... | Line -... | ||
3821 | intel_flush_display_plane(dev_priv, pipe); |
- | |
3822 | } |
- | |
3823 | - | ||
3824 | gen7_setup_fixed_func_scheduler(dev_priv); |
- | |
3825 | 4975 | GEN7_SQ_CHICKEN_MBCUNIT_SQINTMOB); |
|
3826 | /* WaDisable4x2SubspanOptimization */ |
4976 | |
Line 3827... | Line -... | ||
3827 | I915_WRITE(CACHE_MODE_1, |
- | |
3828 | _MASKED_BIT_ENABLE(PIXEL_SUBSPAN_COLLECT_OPT_DISABLE)); |
4977 | /* WaVSRefCountFullforceMissDisable:hsw */ |
3829 | - | ||
3830 | /* WaMbcDriverBootEnable */ |
4978 | gen7_setup_fixed_func_scheduler(dev_priv); |
3831 | I915_WRITE(GEN6_MBCTL, I915_READ(GEN6_MBCTL) | |
- | |
3832 | GEN6_MBCTL_ENABLE_BOOT_FETCH); |
4979 | |
3833 | - | ||
3834 | /* WaSwitchSolVfFArbitrationPriority */ |
- | |
Line 3835... | Line 4980... | ||
3835 | I915_WRITE(GAM_ECOCHK, I915_READ(GAM_ECOCHK) | HSW_ECOCHK_ARB_PRIO_SOL); |
4980 | /* WaDisable4x2SubspanOptimization:hsw */ |
3836 | 4981 | I915_WRITE(CACHE_MODE_1, |
|
Line 3837... | Line 4982... | ||
3837 | /* XXX: This is a workaround for early silicon revisions and should be |
4982 | _MASKED_BIT_ENABLE(PIXEL_SUBSPAN_COLLECT_OPT_DISABLE)); |
3838 | * removed later. |
4983 | |
3839 | */ |
4984 | /* WaSwitchSolVfFArbitrationPriority:hsw */ |
3840 | I915_WRITE(WM_DBG, |
- | |
3841 | I915_READ(WM_DBG) | |
4985 | I915_WRITE(GAM_ECOCHK, I915_READ(GAM_ECOCHK) | HSW_ECOCHK_ARB_PRIO_SOL); |
Line 3842... | Line 4986... | ||
3842 | WM_DBG_DISALLOW_MULTIPLE_LP | |
4986 | |
3843 | WM_DBG_DISALLOW_SPRITE | |
4987 | /* WaRsPkgCStateDisplayPMReq:hsw */ |
3844 | WM_DBG_DISALLOW_MAXFIFO); |
4988 | I915_WRITE(CHICKEN_PAR1_1, |
Line 3845... | Line 4989... | ||
3845 | 4989 | I915_READ(CHICKEN_PAR1_1) | FORCE_ARB_IDLE_PLANES); |
|
Line 3846... | Line 4990... | ||
3846 | lpt_init_clock_gating(dev); |
4990 | |
3847 | } |
4991 | lpt_init_clock_gating(dev); |
3848 | 4992 | } |
|
Line 3849... | Line 4993... | ||
3849 | static void ivybridge_init_clock_gating(struct drm_device *dev) |
4993 | |
3850 | { |
4994 | static void ivybridge_init_clock_gating(struct drm_device *dev) |
3851 | struct drm_i915_private *dev_priv = dev->dev_private; |
4995 | { |
3852 | int pipe; |
4996 | struct drm_i915_private *dev_priv = dev->dev_private; |
Line 3853... | Line 4997... | ||
3853 | uint32_t snpcr; |
4997 | uint32_t snpcr; |
3854 | 4998 | ||
3855 | I915_WRITE(WM3_LP_ILK, 0); |
4999 | I915_WRITE(WM3_LP_ILK, 0); |
3856 | I915_WRITE(WM2_LP_ILK, 0); |
5000 | I915_WRITE(WM2_LP_ILK, 0); |
3857 | I915_WRITE(WM1_LP_ILK, 0); |
5001 | I915_WRITE(WM1_LP_ILK, 0); |
3858 | 5002 | ||
3859 | I915_WRITE(ILK_DSPCLK_GATE_D, ILK_VRHUNIT_CLOCK_GATE_DISABLE); |
5003 | I915_WRITE(ILK_DSPCLK_GATE_D, ILK_VRHUNIT_CLOCK_GATE_DISABLE); |
Line 3860... | Line 5004... | ||
3860 | 5004 | ||
3861 | /* WaDisableEarlyCull */ |
5005 | /* WaDisableEarlyCull:ivb */ |
3862 | I915_WRITE(_3D_CHICKEN3, |
5006 | I915_WRITE(_3D_CHICKEN3, |
Line 3863... | Line 5007... | ||
3863 | _MASKED_BIT_ENABLE(_3D_CHICKEN_SF_DISABLE_OBJEND_CULL)); |
5007 | _MASKED_BIT_ENABLE(_3D_CHICKEN_SF_DISABLE_OBJEND_CULL)); |
3864 | 5008 | ||
3865 | /* WaDisableBackToBackFlipFix */ |
5009 | /* WaDisableBackToBackFlipFix:ivb */ |
3866 | I915_WRITE(IVB_CHICKEN3, |
5010 | I915_WRITE(IVB_CHICKEN3, |
3867 | CHICKEN3_DGMG_REQ_OUT_FIX_DISABLE | |
5011 | CHICKEN3_DGMG_REQ_OUT_FIX_DISABLE | |
3868 | CHICKEN3_DGMG_DONE_FIX_DISABLE); |
5012 | CHICKEN3_DGMG_DONE_FIX_DISABLE); |
Line 3890... | Line 5034... | ||
3890 | else |
5034 | else |
3891 | I915_WRITE(GEN7_ROW_CHICKEN2_GT2, |
5035 | I915_WRITE(GEN7_ROW_CHICKEN2_GT2, |
3892 | _MASKED_BIT_ENABLE(DOP_CLOCK_GATING_DISABLE)); |
5036 | _MASKED_BIT_ENABLE(DOP_CLOCK_GATING_DISABLE)); |
Line 3893... | Line 5037... | ||
3893 | 5037 | ||
3894 | 5038 | ||
3895 | /* WaForceL3Serialization */ |
5039 | /* WaForceL3Serialization:ivb */ |
Line 3896... | Line 5040... | ||
3896 | I915_WRITE(GEN7_L3SQCREG4, I915_READ(GEN7_L3SQCREG4) & |
5040 | I915_WRITE(GEN7_L3SQCREG4, I915_READ(GEN7_L3SQCREG4) & |
3897 | ~L3SQ_URB_READ_CAM_MATCH_DISABLE); |
5041 | ~L3SQ_URB_READ_CAM_MATCH_DISABLE); |
Line 3905... | Line 5049... | ||
3905 | * |
5049 | * |
3906 | * According to the spec, bit 11 (RCCUNIT) must also be set, |
5050 | * According to the spec, bit 11 (RCCUNIT) must also be set, |
3907 | * but we didn't debug actual testcases to find it out. |
5051 | * but we didn't debug actual testcases to find it out. |
3908 | * |
5052 | * |
3909 | * According to the spec, bit 13 (RCZUNIT) must be set on IVB. |
5053 | * According to the spec, bit 13 (RCZUNIT) must be set on IVB. |
3910 | * This implements the WaDisableRCZUnitClockGating workaround. |
5054 | * This implements the WaDisableRCZUnitClockGating:ivb workaround. |
3911 | */ |
5055 | */ |
3912 | I915_WRITE(GEN6_UCGCTL2, |
5056 | I915_WRITE(GEN6_UCGCTL2, |
3913 | GEN6_RCZUNIT_CLOCK_GATE_DISABLE | |
5057 | GEN6_RCZUNIT_CLOCK_GATE_DISABLE | |
3914 | GEN6_RCCUNIT_CLOCK_GATE_DISABLE); |
5058 | GEN6_RCCUNIT_CLOCK_GATE_DISABLE); |
Line 3915... | Line 5059... | ||
3915 | 5059 | ||
3916 | /* This is required by WaCatErrorRejectionIssue */ |
5060 | /* This is required by WaCatErrorRejectionIssue:ivb */ |
3917 | I915_WRITE(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG, |
5061 | I915_WRITE(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG, |
3918 | I915_READ(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) | |
5062 | I915_READ(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) | |
Line 3919... | Line 5063... | ||
3919 | GEN7_SQ_CHICKEN_MBCUNIT_SQINTMOB); |
5063 | GEN7_SQ_CHICKEN_MBCUNIT_SQINTMOB); |
3920 | - | ||
3921 | for_each_pipe(pipe) { |
- | |
3922 | I915_WRITE(DSPCNTR(pipe), |
- | |
3923 | I915_READ(DSPCNTR(pipe)) | |
- | |
3924 | DISPPLANE_TRICKLE_FEED_DISABLE); |
- | |
3925 | intel_flush_display_plane(dev_priv, pipe); |
- | |
3926 | } |
- | |
3927 | - | ||
3928 | /* WaMbcDriverBootEnable */ |
- | |
Line -... | Line 5064... | ||
- | 5064 | ||
3929 | I915_WRITE(GEN6_MBCTL, I915_READ(GEN6_MBCTL) | |
5065 | g4x_disable_trickle_feed(dev); |
Line 3930... | Line 5066... | ||
3930 | GEN6_MBCTL_ENABLE_BOOT_FETCH); |
5066 | |
3931 | 5067 | /* WaVSRefCountFullforceMissDisable:ivb */ |
|
3932 | gen7_setup_fixed_func_scheduler(dev_priv); |
5068 | gen7_setup_fixed_func_scheduler(dev_priv); |
Line 3933... | Line 5069... | ||
3933 | 5069 | ||
3934 | /* WaDisable4x2SubspanOptimization */ |
5070 | /* WaDisable4x2SubspanOptimization:ivb */ |
Line 3947... | Line 5083... | ||
3947 | } |
5083 | } |
Line 3948... | Line 5084... | ||
3948 | 5084 | ||
3949 | static void valleyview_init_clock_gating(struct drm_device *dev) |
5085 | static void valleyview_init_clock_gating(struct drm_device *dev) |
3950 | { |
5086 | { |
3951 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | |
Line 3952... | Line -... | ||
3952 | int pipe; |
- | |
3953 | - | ||
3954 | I915_WRITE(WM3_LP_ILK, 0); |
5087 | struct drm_i915_private *dev_priv = dev->dev_private; |
Line 3955... | Line -... | ||
3955 | I915_WRITE(WM2_LP_ILK, 0); |
- | |
3956 | I915_WRITE(WM1_LP_ILK, 0); |
- | |
3957 | 5088 | ||
3958 | I915_WRITE(ILK_DSPCLK_GATE_D, ILK_VRHUNIT_CLOCK_GATE_DISABLE); |
5089 | I915_WRITE(DSPCLK_GATE_D, VRHUNIT_CLOCK_GATE_DISABLE); |
3959 | 5090 | ||
Line 3960... | Line 5091... | ||
3960 | /* WaDisableEarlyCull */ |
5091 | /* WaDisableEarlyCull:vlv */ |
3961 | I915_WRITE(_3D_CHICKEN3, |
5092 | I915_WRITE(_3D_CHICKEN3, |
3962 | _MASKED_BIT_ENABLE(_3D_CHICKEN_SF_DISABLE_OBJEND_CULL)); |
5093 | _MASKED_BIT_ENABLE(_3D_CHICKEN_SF_DISABLE_OBJEND_CULL)); |
3963 | 5094 | ||
Line 3964... | Line 5095... | ||
3964 | /* WaDisableBackToBackFlipFix */ |
5095 | /* WaDisableBackToBackFlipFix:vlv */ |
3965 | I915_WRITE(IVB_CHICKEN3, |
5096 | I915_WRITE(IVB_CHICKEN3, |
3966 | CHICKEN3_DGMG_REQ_OUT_FIX_DISABLE | |
5097 | CHICKEN3_DGMG_REQ_OUT_FIX_DISABLE | |
3967 | CHICKEN3_DGMG_DONE_FIX_DISABLE); |
5098 | CHICKEN3_DGMG_DONE_FIX_DISABLE); |
Line 3968... | Line 5099... | ||
3968 | 5099 | ||
3969 | /* WaDisablePSDDualDispatchEnable */ |
5100 | /* WaDisablePSDDualDispatchEnable:vlv */ |
3970 | I915_WRITE(GEN7_HALF_SLICE_CHICKEN1, |
5101 | I915_WRITE(GEN7_HALF_SLICE_CHICKEN1, |
Line 3971... | Line 5102... | ||
3971 | _MASKED_BIT_ENABLE(GEN7_MAX_PS_THREAD_DEP | |
5102 | _MASKED_BIT_ENABLE(GEN7_MAX_PS_THREAD_DEP | |
3972 | GEN7_PSD_SINGLE_PORT_DISPATCH_ENABLE)); |
5103 | GEN7_PSD_SINGLE_PORT_DISPATCH_ENABLE)); |
3973 | 5104 | ||
Line 3974... | Line 5105... | ||
3974 | /* Apply the WaDisableRHWOOptimizationForRenderHang workaround. */ |
5105 | /* Apply the WaDisableRHWOOptimizationForRenderHang:vlv workaround. */ |
3975 | I915_WRITE(GEN7_COMMON_SLICE_CHICKEN1, |
5106 | I915_WRITE(GEN7_COMMON_SLICE_CHICKEN1, |
3976 | GEN7_CSC1_RHWO_OPT_DISABLE_IN_RCC); |
5107 | GEN7_CSC1_RHWO_OPT_DISABLE_IN_RCC); |
Line 3977... | Line 5108... | ||
3977 | 5108 | ||
3978 | /* WaApplyL3ControlAndL3ChickenMode requires those two on Ivy Bridge */ |
5109 | /* WaApplyL3ControlAndL3ChickenMode:vlv */ |
3979 | I915_WRITE(GEN7_L3CNTLREG1, I915_READ(GEN7_L3CNTLREG1) | GEN7_L3AGDIS); |
5110 | I915_WRITE(GEN7_L3CNTLREG1, I915_READ(GEN7_L3CNTLREG1) | GEN7_L3AGDIS); |
Line 3980... | Line -... | ||
3980 | I915_WRITE(GEN7_L3_CHICKEN_MODE_REGISTER, GEN7_WA_L3_CHICKEN_MODE); |
- | |
3981 | - | ||
3982 | /* WaForceL3Serialization */ |
- | |
3983 | I915_WRITE(GEN7_L3SQCREG4, I915_READ(GEN7_L3SQCREG4) & |
- | |
3984 | ~L3SQ_URB_READ_CAM_MATCH_DISABLE); |
5111 | I915_WRITE(GEN7_L3_CHICKEN_MODE_REGISTER, GEN7_WA_L3_CHICKEN_MODE); |
3985 | 5112 | ||
3986 | /* WaDisableDopClockGating */ |
5113 | /* WaForceL3Serialization:vlv */ |
3987 | I915_WRITE(GEN7_ROW_CHICKEN2, |
5114 | I915_WRITE(GEN7_L3SQCREG4, I915_READ(GEN7_L3SQCREG4) & |
Line 3988... | Line -... | ||
3988 | _MASKED_BIT_ENABLE(DOP_CLOCK_GATING_DISABLE)); |
- | |
3989 | - | ||
3990 | /* WaForceL3Serialization */ |
- | |
3991 | I915_WRITE(GEN7_L3SQCREG4, I915_READ(GEN7_L3SQCREG4) & |
- | |
3992 | ~L3SQ_URB_READ_CAM_MATCH_DISABLE); |
- | |
3993 | 5115 | ~L3SQ_URB_READ_CAM_MATCH_DISABLE); |
|
3994 | /* This is required by WaCatErrorRejectionIssue */ |
5116 | |
3995 | I915_WRITE(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG, |
5117 | /* WaDisableDopClockGating:vlv */ |
3996 | I915_READ(GEN7_SQ_CHICKEN_MBCUNIT_CONFIG) | |
5118 | I915_WRITE(GEN7_ROW_CHICKEN2, |
3997 | GEN7_SQ_CHICKEN_MBCUNIT_SQINTMOB); |
5119 | _MASKED_BIT_ENABLE(DOP_CLOCK_GATING_DISABLE)); |
Line 4010... | Line 5132... | ||
4010 | * |
5132 | * |
4011 | * According to the spec, bit 11 (RCCUNIT) must also be set, |
5133 | * According to the spec, bit 11 (RCCUNIT) must also be set, |
4012 | * but we didn't debug actual testcases to find it out. |
5134 | * but we didn't debug actual testcases to find it out. |
4013 | * |
5135 | * |
4014 | * According to the spec, bit 13 (RCZUNIT) must be set on IVB. |
5136 | * According to the spec, bit 13 (RCZUNIT) must be set on IVB. |
4015 | * This implements the WaDisableRCZUnitClockGating workaround. |
5137 | * This implements the WaDisableRCZUnitClockGating:vlv workaround. |
4016 | * |
5138 | * |
4017 | * Also apply WaDisableVDSUnitClockGating and |
5139 | * Also apply WaDisableVDSUnitClockGating:vlv and |
4018 | * WaDisableRCPBUnitClockGating. |
5140 | * WaDisableRCPBUnitClockGating:vlv. |
4019 | */ |
5141 | */ |
4020 | I915_WRITE(GEN6_UCGCTL2, |
5142 | I915_WRITE(GEN6_UCGCTL2, |
4021 | GEN7_VDSUNIT_CLOCK_GATE_DISABLE | |
5143 | GEN7_VDSUNIT_CLOCK_GATE_DISABLE | |
4022 | GEN7_TDLUNIT_CLOCK_GATE_DISABLE | |
5144 | GEN7_TDLUNIT_CLOCK_GATE_DISABLE | |
4023 | GEN6_RCZUNIT_CLOCK_GATE_DISABLE | |
5145 | GEN6_RCZUNIT_CLOCK_GATE_DISABLE | |
4024 | GEN6_RCPBUNIT_CLOCK_GATE_DISABLE | |
5146 | GEN6_RCPBUNIT_CLOCK_GATE_DISABLE | |
4025 | GEN6_RCCUNIT_CLOCK_GATE_DISABLE); |
5147 | GEN6_RCCUNIT_CLOCK_GATE_DISABLE); |
Line 4026... | Line 5148... | ||
4026 | 5148 | ||
Line 4027... | Line -... | ||
4027 | I915_WRITE(GEN7_UCGCTL4, GEN7_L3BANK2X_CLOCK_GATE_DISABLE); |
- | |
4028 | - | ||
4029 | for_each_pipe(pipe) { |
- | |
4030 | I915_WRITE(DSPCNTR(pipe), |
5149 | I915_WRITE(GEN7_UCGCTL4, GEN7_L3BANK2X_CLOCK_GATE_DISABLE); |
4031 | I915_READ(DSPCNTR(pipe)) | |
- | |
4032 | DISPPLANE_TRICKLE_FEED_DISABLE); |
- | |
Line 4033... | Line 5150... | ||
4033 | intel_flush_display_plane(dev_priv, pipe); |
5150 | |
4034 | } |
5151 | I915_WRITE(MI_ARB_VLV, MI_ARB_DISPLAY_TRICKLE_FEED_DISABLE); |
Line 4035... | Line 5152... | ||
4035 | 5152 | ||
4036 | I915_WRITE(CACHE_MODE_1, |
5153 | I915_WRITE(CACHE_MODE_1, |
4037 | _MASKED_BIT_ENABLE(PIXEL_SUBSPAN_COLLECT_OPT_DISABLE)); |
5154 | _MASKED_BIT_ENABLE(PIXEL_SUBSPAN_COLLECT_OPT_DISABLE)); |
4038 | 5155 | ||
4039 | /* |
5156 | /* |
4040 | * WaDisableVLVClockGating_VBIIssue |
5157 | * WaDisableVLVClockGating_VBIIssue:vlv |
Line 4071... | Line 5188... | ||
4071 | I915_WRITE(DSPCLK_GATE_D, dspclk_gate); |
5188 | I915_WRITE(DSPCLK_GATE_D, dspclk_gate); |
Line 4072... | Line 5189... | ||
4072 | 5189 | ||
4073 | /* WaDisableRenderCachePipelinedFlush */ |
5190 | /* WaDisableRenderCachePipelinedFlush */ |
4074 | I915_WRITE(CACHE_MODE_0, |
5191 | I915_WRITE(CACHE_MODE_0, |
- | 5192 | _MASKED_BIT_ENABLE(CM0_PIPELINED_RENDER_FLUSH_DISABLE)); |
|
- | 5193 | ||
4075 | _MASKED_BIT_ENABLE(CM0_PIPELINED_RENDER_FLUSH_DISABLE)); |
5194 | g4x_disable_trickle_feed(dev); |
Line 4076... | Line 5195... | ||
4076 | } |
5195 | } |
4077 | 5196 | ||
4078 | static void crestline_init_clock_gating(struct drm_device *dev) |
5197 | static void crestline_init_clock_gating(struct drm_device *dev) |
Line 4082... | Line 5201... | ||
4082 | I915_WRITE(RENCLK_GATE_D1, I965_RCC_CLOCK_GATE_DISABLE); |
5201 | I915_WRITE(RENCLK_GATE_D1, I965_RCC_CLOCK_GATE_DISABLE); |
4083 | I915_WRITE(RENCLK_GATE_D2, 0); |
5202 | I915_WRITE(RENCLK_GATE_D2, 0); |
4084 | I915_WRITE(DSPCLK_GATE_D, 0); |
5203 | I915_WRITE(DSPCLK_GATE_D, 0); |
4085 | I915_WRITE(RAMCLK_GATE_D, 0); |
5204 | I915_WRITE(RAMCLK_GATE_D, 0); |
4086 | I915_WRITE16(DEUC, 0); |
5205 | I915_WRITE16(DEUC, 0); |
- | 5206 | I915_WRITE(MI_ARB_STATE, |
|
- | 5207 | _MASKED_BIT_ENABLE(MI_ARB_DISPLAY_TRICKLE_FEED_DISABLE)); |
|
4087 | } |
5208 | } |
Line 4088... | Line 5209... | ||
4088 | 5209 | ||
4089 | static void broadwater_init_clock_gating(struct drm_device *dev) |
5210 | static void broadwater_init_clock_gating(struct drm_device *dev) |
4090 | { |
5211 | { |
Line 4094... | Line 5215... | ||
4094 | I965_RCC_CLOCK_GATE_DISABLE | |
5215 | I965_RCC_CLOCK_GATE_DISABLE | |
4095 | I965_RCPB_CLOCK_GATE_DISABLE | |
5216 | I965_RCPB_CLOCK_GATE_DISABLE | |
4096 | I965_ISC_CLOCK_GATE_DISABLE | |
5217 | I965_ISC_CLOCK_GATE_DISABLE | |
4097 | I965_FBC_CLOCK_GATE_DISABLE); |
5218 | I965_FBC_CLOCK_GATE_DISABLE); |
4098 | I915_WRITE(RENCLK_GATE_D2, 0); |
5219 | I915_WRITE(RENCLK_GATE_D2, 0); |
- | 5220 | I915_WRITE(MI_ARB_STATE, |
|
- | 5221 | _MASKED_BIT_ENABLE(MI_ARB_DISPLAY_TRICKLE_FEED_DISABLE)); |
|
4099 | } |
5222 | } |
Line 4100... | Line 5223... | ||
4100 | 5223 | ||
4101 | static void gen3_init_clock_gating(struct drm_device *dev) |
5224 | static void gen3_init_clock_gating(struct drm_device *dev) |
4102 | { |
5225 | { |
Line 4133... | Line 5256... | ||
4133 | struct drm_i915_private *dev_priv = dev->dev_private; |
5256 | struct drm_i915_private *dev_priv = dev->dev_private; |
Line 4134... | Line 5257... | ||
4134 | 5257 | ||
4135 | dev_priv->display.init_clock_gating(dev); |
5258 | dev_priv->display.init_clock_gating(dev); |
Line -... | Line 5259... | ||
- | 5259 | } |
|
- | 5260 | ||
- | 5261 | void intel_suspend_hw(struct drm_device *dev) |
|
- | 5262 | { |
|
- | 5263 | if (HAS_PCH_LPT(dev)) |
|
- | 5264 | lpt_suspend_hw(dev); |
|
4136 | } |
5265 | } |
4137 | 5266 | ||
4138 | /** |
5267 | /** |
4139 | * We should only use the power well if we explicitly asked the hardware to |
5268 | * We should only use the power well if we explicitly asked the hardware to |
4140 | * enable it, so check if it's enabled and also check if we've requested it to |
5269 | * enable it, so check if it's enabled and also check if we've requested it to |
4141 | * be enabled. |
5270 | * be enabled. |
- | 5271 | */ |
|
4142 | */ |
5272 | bool intel_display_power_enabled(struct drm_device *dev, |
4143 | bool intel_using_power_well(struct drm_device *dev) |
5273 | enum intel_display_power_domain domain) |
Line 4144... | Line 5274... | ||
4144 | { |
5274 | { |
- | 5275 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 5276 | ||
- | 5277 | if (!HAS_POWER_WELL(dev)) |
|
4145 | struct drm_i915_private *dev_priv = dev->dev_private; |
5278 | return true; |
4146 | 5279 | ||
4147 | if (IS_HASWELL(dev)) |
- | |
4148 | return I915_READ(HSW_PWR_WELL_DRIVER) == |
5280 | switch (domain) { |
- | 5281 | case POWER_DOMAIN_PIPE_A: |
|
- | 5282 | case POWER_DOMAIN_TRANSCODER_EDP: |
|
- | 5283 | return true; |
|
- | 5284 | case POWER_DOMAIN_PIPE_B: |
|
- | 5285 | case POWER_DOMAIN_PIPE_C: |
|
- | 5286 | case POWER_DOMAIN_PIPE_A_PANEL_FITTER: |
|
- | 5287 | case POWER_DOMAIN_PIPE_B_PANEL_FITTER: |
|
- | 5288 | case POWER_DOMAIN_PIPE_C_PANEL_FITTER: |
|
- | 5289 | case POWER_DOMAIN_TRANSCODER_A: |
|
- | 5290 | case POWER_DOMAIN_TRANSCODER_B: |
|
- | 5291 | case POWER_DOMAIN_TRANSCODER_C: |
|
- | 5292 | return I915_READ(HSW_PWR_WELL_DRIVER) == |
|
- | 5293 | (HSW_PWR_WELL_ENABLE_REQUEST | HSW_PWR_WELL_STATE_ENABLED); |
|
4149 | (HSW_PWR_WELL_ENABLE | HSW_PWR_WELL_STATE); |
5294 | default: |
Line 4150... | Line 5295... | ||
4150 | else |
5295 | BUG(); |
4151 | return true; |
5296 | } |
4152 | } |
5297 | } |
4153 | 5298 | ||
4154 | void intel_set_power_well(struct drm_device *dev, bool enable) |
5299 | static void __intel_set_power_well(struct drm_device *dev, bool enable) |
Line 4155... | Line -... | ||
4155 | { |
- | |
4156 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | |
4157 | bool is_enabled, enable_requested; |
- | |
4158 | uint32_t tmp; |
- | |
4159 | - | ||
4160 | if (!HAS_POWER_WELL(dev)) |
- | |
4161 | return; |
5300 | { |
4162 | 5301 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
4163 | if (!i915_disable_power_well && !enable) |
5302 | bool is_enabled, enable_requested; |
Line 4164... | Line 5303... | ||
4164 | return; |
5303 | uint32_t tmp; |
4165 | 5304 | ||
4166 | tmp = I915_READ(HSW_PWR_WELL_DRIVER); |
5305 | tmp = I915_READ(HSW_PWR_WELL_DRIVER); |
- | 5306 | is_enabled = tmp & HSW_PWR_WELL_STATE_ENABLED; |
|
Line 4167... | Line 5307... | ||
4167 | is_enabled = tmp & HSW_PWR_WELL_STATE; |
5307 | enable_requested = tmp & HSW_PWR_WELL_ENABLE_REQUEST; |
4168 | enable_requested = tmp & HSW_PWR_WELL_ENABLE; |
5308 | |
4169 | 5309 | if (enable) { |
|
4170 | if (enable) { |
5310 | if (!enable_requested) |
4171 | if (!enable_requested) |
5311 | I915_WRITE(HSW_PWR_WELL_DRIVER, |
4172 | I915_WRITE(HSW_PWR_WELL_DRIVER, HSW_PWR_WELL_ENABLE); |
5312 | HSW_PWR_WELL_ENABLE_REQUEST); |
4173 | 5313 | ||
4174 | if (!is_enabled) { |
5314 | if (!is_enabled) { |
- | 5315 | DRM_DEBUG_KMS("Enabling power well\n"); |
|
- | 5316 | if (wait_for((I915_READ(HSW_PWR_WELL_DRIVER) & |
|
- | 5317 | HSW_PWR_WELL_STATE_ENABLED), 20)) |
|
4175 | DRM_DEBUG_KMS("Enabling power well\n"); |
5318 | DRM_ERROR("Timeout enabling power well\n"); |
- | 5319 | } |
|
4176 | if (wait_for((I915_READ(HSW_PWR_WELL_DRIVER) & |
5320 | } else { |
- | 5321 | if (enable_requested) { |
|
- | 5322 | unsigned long irqflags; |
|
- | 5323 | enum pipe p; |
|
- | 5324 | ||
- | 5325 | I915_WRITE(HSW_PWR_WELL_DRIVER, 0); |
|
- | 5326 | POSTING_READ(HSW_PWR_WELL_DRIVER); |
|
- | 5327 | DRM_DEBUG_KMS("Requesting to disable the power well\n"); |
|
- | 5328 | ||
- | 5329 | /* |
|
- | 5330 | * After this, the registers on the pipes that are part |
|
- | 5331 | * of the power well will become zero, so we have to |
|
- | 5332 | * adjust our counters according to that. |
|
- | 5333 | * |
|
- | 5334 | * FIXME: Should we do this in general in |
|
- | 5335 | * drm_vblank_post_modeset? |
|
- | 5336 | */ |
|
- | 5337 | spin_lock_irqsave(&dev->vbl_lock, irqflags); |
|
- | 5338 | for_each_pipe(p) |
|
- | 5339 | if (p != PIPE_A) |
|
- | 5340 | dev->last_vblank[p] = 0; |
|
- | 5341 | spin_unlock_irqrestore(&dev->vbl_lock, irqflags); |
|
- | 5342 | } |
|
- | 5343 | } |
|
- | 5344 | } |
|
- | 5345 | ||
- | 5346 | static struct i915_power_well *hsw_pwr; |
|
- | 5347 | ||
- | 5348 | /* Display audio driver power well request */ |
|
- | 5349 | void i915_request_power_well(void) |
|
- | 5350 | { |
|
- | 5351 | if (WARN_ON(!hsw_pwr)) |
|
- | 5352 | return; |
|
- | 5353 | ||
- | 5354 | spin_lock_irq(&hsw_pwr->lock); |
|
- | 5355 | if (!hsw_pwr->count++ && |
|
- | 5356 | !hsw_pwr->i915_request) |
|
- | 5357 | __intel_set_power_well(hsw_pwr->device, true); |
|
- | 5358 | spin_unlock_irq(&hsw_pwr->lock); |
|
- | 5359 | } |
|
- | 5360 | EXPORT_SYMBOL_GPL(i915_request_power_well); |
|
- | 5361 | ||
- | 5362 | /* Display audio driver power well release */ |
|
- | 5363 | void i915_release_power_well(void) |
|
- | 5364 | { |
|
- | 5365 | if (WARN_ON(!hsw_pwr)) |
|
- | 5366 | return; |
|
4177 | HSW_PWR_WELL_STATE), 20)) |
5367 | |
- | 5368 | spin_lock_irq(&hsw_pwr->lock); |
|
- | 5369 | WARN_ON(!hsw_pwr->count); |
|
- | 5370 | if (!--hsw_pwr->count && |
|
- | 5371 | !hsw_pwr->i915_request) |
|
- | 5372 | __intel_set_power_well(hsw_pwr->device, false); |
|
- | 5373 | spin_unlock_irq(&hsw_pwr->lock); |
|
- | 5374 | } |
|
- | 5375 | EXPORT_SYMBOL_GPL(i915_release_power_well); |
|
- | 5376 | ||
- | 5377 | int i915_init_power_well(struct drm_device *dev) |
|
- | 5378 | { |
|
- | 5379 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 5380 | ||
4178 | DRM_ERROR("Timeout enabling power well\n"); |
5381 | hsw_pwr = &dev_priv->power_well; |
- | 5382 | ||
- | 5383 | hsw_pwr->device = dev; |
|
- | 5384 | spin_lock_init(&hsw_pwr->lock); |
|
- | 5385 | hsw_pwr->count = 0; |
|
- | 5386 | ||
- | 5387 | return 0; |
|
- | 5388 | } |
|
- | 5389 | ||
- | 5390 | void i915_remove_power_well(struct drm_device *dev) |
|
- | 5391 | { |
|
- | 5392 | hsw_pwr = NULL; |
|
- | 5393 | } |
|
- | 5394 | ||
- | 5395 | void intel_set_power_well(struct drm_device *dev, bool enable) |
|
- | 5396 | { |
|
- | 5397 | struct drm_i915_private *dev_priv = dev->dev_private; |
|
- | 5398 | struct i915_power_well *power_well = &dev_priv->power_well; |
|
- | 5399 | ||
- | 5400 | if (!HAS_POWER_WELL(dev)) |
|
- | 5401 | return; |
|
- | 5402 | ||
- | 5403 | if (!i915_disable_power_well && !enable) |
|
- | 5404 | return; |
|
- | 5405 | ||
- | 5406 | spin_lock_irq(&power_well->lock); |
|
- | 5407 | power_well->i915_request = enable; |
|
- | 5408 | ||
- | 5409 | /* only reject "disable" power well request */ |
|
4179 | } |
5410 | if (power_well->count && !enable) { |
Line 4180... | Line 5411... | ||
4180 | } else { |
5411 | spin_unlock_irq(&power_well->lock); |
4181 | if (enable_requested) { |
5412 | return; |
4182 | I915_WRITE(HSW_PWR_WELL_DRIVER, 0); |
5413 | } |
Line 4201... | Line 5432... | ||
4201 | /* For now, we need the power well to be always enabled. */ |
5432 | /* For now, we need the power well to be always enabled. */ |
4202 | intel_set_power_well(dev, true); |
5433 | intel_set_power_well(dev, true); |
Line 4203... | Line 5434... | ||
4203 | 5434 | ||
4204 | /* We're taking over the BIOS, so clear any requests made by it since |
5435 | /* We're taking over the BIOS, so clear any requests made by it since |
4205 | * the driver is in charge now. */ |
5436 | * the driver is in charge now. */ |
4206 | if (I915_READ(HSW_PWR_WELL_BIOS) & HSW_PWR_WELL_ENABLE) |
5437 | if (I915_READ(HSW_PWR_WELL_BIOS) & HSW_PWR_WELL_ENABLE_REQUEST) |
4207 | I915_WRITE(HSW_PWR_WELL_BIOS, 0); |
5438 | I915_WRITE(HSW_PWR_WELL_BIOS, 0); |
Line -... | Line 5439... | ||
- | 5439 | } |
|
- | 5440 | ||
- | 5441 | /* Disables PC8 so we can use the GMBUS and DP AUX interrupts. */ |
|
- | 5442 | void intel_aux_display_runtime_get(struct drm_i915_private *dev_priv) |
|
- | 5443 | { |
|
- | 5444 | hsw_disable_package_c8(dev_priv); |
|
- | 5445 | } |
|
- | 5446 | ||
- | 5447 | void intel_aux_display_runtime_put(struct drm_i915_private *dev_priv) |
|
- | 5448 | { |
|
- | 5449 | hsw_enable_package_c8(dev_priv); |
|
4208 | } |
5450 | } |
4209 | 5451 | ||
4210 | /* Set up chip specific power management-related functions */ |
5452 | /* Set up chip specific power management-related functions */ |
4211 | void intel_init_pm(struct drm_device *dev) |
5453 | void intel_init_pm(struct drm_device *dev) |
Line 4212... | Line 5454... | ||
4212 | { |
5454 | { |
4213 | struct drm_i915_private *dev_priv = dev->dev_private; |
5455 | struct drm_i915_private *dev_priv = dev->dev_private; |
4214 | 5456 | ||
- | 5457 | if (I915_HAS_FBC(dev)) { |
|
- | 5458 | if (HAS_PCH_SPLIT(dev)) { |
|
- | 5459 | dev_priv->display.fbc_enabled = ironlake_fbc_enabled; |
|
- | 5460 | if (IS_IVYBRIDGE(dev) || IS_HASWELL(dev)) |
|
4215 | if (I915_HAS_FBC(dev)) { |
5461 | dev_priv->display.enable_fbc = |
- | 5462 | gen7_enable_fbc; |
|
4216 | if (HAS_PCH_SPLIT(dev)) { |
5463 | else |
4217 | dev_priv->display.fbc_enabled = ironlake_fbc_enabled; |
5464 | dev_priv->display.enable_fbc = |
4218 | dev_priv->display.enable_fbc = ironlake_enable_fbc; |
5465 | ironlake_enable_fbc; |
4219 | dev_priv->display.disable_fbc = ironlake_disable_fbc; |
5466 | dev_priv->display.disable_fbc = ironlake_disable_fbc; |
4220 | } else if (IS_GM45(dev)) { |
5467 | } else if (IS_GM45(dev)) { |
Line 4235... | Line 5482... | ||
4235 | else if (IS_GEN5(dev)) |
5482 | else if (IS_GEN5(dev)) |
4236 | i915_ironlake_get_mem_freq(dev); |
5483 | i915_ironlake_get_mem_freq(dev); |
Line 4237... | Line 5484... | ||
4237 | 5484 | ||
4238 | /* For FIFO watermark updates */ |
5485 | /* For FIFO watermark updates */ |
- | 5486 | if (HAS_PCH_SPLIT(dev)) { |
|
- | 5487 | intel_setup_wm_latency(dev); |
|
4239 | if (HAS_PCH_SPLIT(dev)) { |
5488 | |
4240 | if (IS_GEN5(dev)) { |
5489 | if (IS_GEN5(dev)) { |
- | 5490 | if (dev_priv->wm.pri_latency[1] && |
|
- | 5491 | dev_priv->wm.spr_latency[1] && |
|
4241 | if (I915_READ(MLTR_ILK) & ILK_SRLT_MASK) |
5492 | dev_priv->wm.cur_latency[1]) |
4242 | dev_priv->display.update_wm = ironlake_update_wm; |
5493 | dev_priv->display.update_wm = ironlake_update_wm; |
4243 | else { |
5494 | else { |
4244 | DRM_DEBUG_KMS("Failed to get proper latency. " |
5495 | DRM_DEBUG_KMS("Failed to get proper latency. " |
4245 | "Disable CxSR\n"); |
5496 | "Disable CxSR\n"); |
4246 | dev_priv->display.update_wm = NULL; |
5497 | dev_priv->display.update_wm = NULL; |
4247 | } |
5498 | } |
4248 | dev_priv->display.init_clock_gating = ironlake_init_clock_gating; |
5499 | dev_priv->display.init_clock_gating = ironlake_init_clock_gating; |
4249 | } else if (IS_GEN6(dev)) { |
5500 | } else if (IS_GEN6(dev)) { |
- | 5501 | if (dev_priv->wm.pri_latency[0] && |
|
- | 5502 | dev_priv->wm.spr_latency[0] && |
|
4250 | if (SNB_READ_WM0_LATENCY()) { |
5503 | dev_priv->wm.cur_latency[0]) { |
4251 | dev_priv->display.update_wm = sandybridge_update_wm; |
5504 | dev_priv->display.update_wm = sandybridge_update_wm; |
4252 | dev_priv->display.update_sprite_wm = sandybridge_update_sprite_wm; |
5505 | dev_priv->display.update_sprite_wm = sandybridge_update_sprite_wm; |
4253 | } else { |
5506 | } else { |
4254 | DRM_DEBUG_KMS("Failed to read display plane latency. " |
5507 | DRM_DEBUG_KMS("Failed to read display plane latency. " |
4255 | "Disable CxSR\n"); |
5508 | "Disable CxSR\n"); |
4256 | dev_priv->display.update_wm = NULL; |
5509 | dev_priv->display.update_wm = NULL; |
4257 | } |
5510 | } |
4258 | dev_priv->display.init_clock_gating = gen6_init_clock_gating; |
5511 | dev_priv->display.init_clock_gating = gen6_init_clock_gating; |
4259 | } else if (IS_IVYBRIDGE(dev)) { |
5512 | } else if (IS_IVYBRIDGE(dev)) { |
- | 5513 | if (dev_priv->wm.pri_latency[0] && |
|
- | 5514 | dev_priv->wm.spr_latency[0] && |
|
4260 | if (SNB_READ_WM0_LATENCY()) { |
5515 | dev_priv->wm.cur_latency[0]) { |
4261 | dev_priv->display.update_wm = ivybridge_update_wm; |
5516 | dev_priv->display.update_wm = ivybridge_update_wm; |
4262 | dev_priv->display.update_sprite_wm = sandybridge_update_sprite_wm; |
5517 | dev_priv->display.update_sprite_wm = sandybridge_update_sprite_wm; |
4263 | } else { |
5518 | } else { |
4264 | DRM_DEBUG_KMS("Failed to read display plane latency. " |
5519 | DRM_DEBUG_KMS("Failed to read display plane latency. " |
4265 | "Disable CxSR\n"); |
5520 | "Disable CxSR\n"); |
4266 | dev_priv->display.update_wm = NULL; |
5521 | dev_priv->display.update_wm = NULL; |
4267 | } |
5522 | } |
4268 | dev_priv->display.init_clock_gating = ivybridge_init_clock_gating; |
5523 | dev_priv->display.init_clock_gating = ivybridge_init_clock_gating; |
4269 | } else if (IS_HASWELL(dev)) { |
5524 | } else if (IS_HASWELL(dev)) { |
- | 5525 | if (dev_priv->wm.pri_latency[0] && |
|
- | 5526 | dev_priv->wm.spr_latency[0] && |
|
4270 | if (SNB_READ_WM0_LATENCY()) { |
5527 | dev_priv->wm.cur_latency[0]) { |
4271 | dev_priv->display.update_wm = sandybridge_update_wm; |
5528 | dev_priv->display.update_wm = haswell_update_wm; |
4272 | dev_priv->display.update_sprite_wm = sandybridge_update_sprite_wm; |
5529 | dev_priv->display.update_sprite_wm = |
4273 | dev_priv->display.update_linetime_wm = haswell_update_linetime_wm; |
5530 | haswell_update_sprite_wm; |
4274 | } else { |
5531 | } else { |
4275 | DRM_DEBUG_KMS("Failed to read display plane latency. " |
5532 | DRM_DEBUG_KMS("Failed to read display plane latency. " |
4276 | "Disable CxSR\n"); |
5533 | "Disable CxSR\n"); |
4277 | dev_priv->display.update_wm = NULL; |
5534 | dev_priv->display.update_wm = NULL; |
Line 4328... | Line 5585... | ||
4328 | else |
5585 | else |
4329 | dev_priv->display.get_fifo_size = i830_get_fifo_size; |
5586 | dev_priv->display.get_fifo_size = i830_get_fifo_size; |
4330 | } |
5587 | } |
4331 | } |
5588 | } |
Line 4332... | Line -... | ||
4332 | - | ||
4333 | static void __gen6_gt_wait_for_thread_c0(struct drm_i915_private *dev_priv) |
- | |
4334 | { |
- | |
4335 | u32 gt_thread_status_mask; |
- | |
4336 | - | ||
4337 | if (IS_HASWELL(dev_priv->dev)) |
- | |
4338 | gt_thread_status_mask = GEN6_GT_THREAD_STATUS_CORE_MASK_HSW; |
- | |
4339 | else |
- | |
4340 | gt_thread_status_mask = GEN6_GT_THREAD_STATUS_CORE_MASK; |
- | |
4341 | - | ||
4342 | /* w/a for a sporadic read returning 0 by waiting for the GT |
- | |
4343 | * thread to wake up. |
- | |
4344 | */ |
- | |
4345 | if (wait_for_atomic_us((I915_READ_NOTRACE(GEN6_GT_THREAD_STATUS_REG) & gt_thread_status_mask) == 0, 500)) |
- | |
4346 | DRM_ERROR("GT thread status wait timed out\n"); |
- | |
4347 | } |
- | |
4348 | - | ||
4349 | static void __gen6_gt_force_wake_reset(struct drm_i915_private *dev_priv) |
- | |
4350 | { |
- | |
4351 | I915_WRITE_NOTRACE(FORCEWAKE, 0); |
- | |
4352 | POSTING_READ(ECOBUS); /* something from same cacheline, but !FORCEWAKE */ |
- | |
4353 | } |
- | |
4354 | - | ||
4355 | static void __gen6_gt_force_wake_get(struct drm_i915_private *dev_priv) |
- | |
4356 | { |
- | |
4357 | if (wait_for_atomic((I915_READ_NOTRACE(FORCEWAKE_ACK) & 1) == 0, |
- | |
4358 | FORCEWAKE_ACK_TIMEOUT_MS)) |
- | |
4359 | DRM_ERROR("Timed out waiting for forcewake old ack to clear.\n"); |
- | |
4360 | - | ||
4361 | I915_WRITE_NOTRACE(FORCEWAKE, 1); |
- | |
4362 | POSTING_READ(ECOBUS); /* something from same cacheline, but !FORCEWAKE */ |
- | |
4363 | - | ||
4364 | if (wait_for_atomic((I915_READ_NOTRACE(FORCEWAKE_ACK) & 1), |
- | |
4365 | FORCEWAKE_ACK_TIMEOUT_MS)) |
- | |
4366 | DRM_ERROR("Timed out waiting for forcewake to ack request.\n"); |
- | |
4367 | - | ||
4368 | __gen6_gt_wait_for_thread_c0(dev_priv); |
- | |
4369 | } |
- | |
4370 | - | ||
4371 | static void __gen6_gt_force_wake_mt_reset(struct drm_i915_private *dev_priv) |
- | |
4372 | { |
- | |
4373 | I915_WRITE_NOTRACE(FORCEWAKE_MT, _MASKED_BIT_DISABLE(0xffff)); |
- | |
4374 | /* something from same cacheline, but !FORCEWAKE_MT */ |
- | |
4375 | POSTING_READ(ECOBUS); |
- | |
4376 | } |
- | |
4377 | - | ||
4378 | static void __gen6_gt_force_wake_mt_get(struct drm_i915_private *dev_priv) |
- | |
4379 | { |
- | |
4380 | u32 forcewake_ack; |
- | |
4381 | - | ||
4382 | if (IS_HASWELL(dev_priv->dev)) |
- | |
4383 | forcewake_ack = FORCEWAKE_ACK_HSW; |
- | |
4384 | else |
- | |
4385 | forcewake_ack = FORCEWAKE_MT_ACK; |
- | |
4386 | - | ||
4387 | if (wait_for_atomic((I915_READ_NOTRACE(forcewake_ack) & FORCEWAKE_KERNEL) == 0, |
- | |
4388 | FORCEWAKE_ACK_TIMEOUT_MS)) |
- | |
4389 | DRM_ERROR("Timed out waiting for forcewake old ack to clear.\n"); |
- | |
4390 | - | ||
4391 | I915_WRITE_NOTRACE(FORCEWAKE_MT, _MASKED_BIT_ENABLE(FORCEWAKE_KERNEL)); |
- | |
4392 | /* something from same cacheline, but !FORCEWAKE_MT */ |
- | |
4393 | POSTING_READ(ECOBUS); |
- | |
4394 | - | ||
4395 | if (wait_for_atomic((I915_READ_NOTRACE(forcewake_ack) & FORCEWAKE_KERNEL), |
- | |
4396 | FORCEWAKE_ACK_TIMEOUT_MS)) |
- | |
4397 | DRM_ERROR("Timed out waiting for forcewake to ack request.\n"); |
- | |
4398 | - | ||
4399 | __gen6_gt_wait_for_thread_c0(dev_priv); |
- | |
4400 | } |
- | |
4401 | - | ||
4402 | /* |
- | |
4403 | * Generally this is called implicitly by the register read function. However, |
- | |
4404 | * if some sequence requires the GT to not power down then this function should |
- | |
4405 | * be called at the beginning of the sequence followed by a call to |
- | |
4406 | * gen6_gt_force_wake_put() at the end of the sequence. |
- | |
4407 | */ |
- | |
4408 | void gen6_gt_force_wake_get(struct drm_i915_private *dev_priv) |
- | |
4409 | { |
- | |
4410 | unsigned long irqflags; |
- | |
4411 | - | ||
4412 | spin_lock_irqsave(&dev_priv->gt_lock, irqflags); |
- | |
4413 | if (dev_priv->forcewake_count++ == 0) |
- | |
4414 | dev_priv->gt.force_wake_get(dev_priv); |
- | |
4415 | spin_unlock_irqrestore(&dev_priv->gt_lock, irqflags); |
- | |
4416 | } |
- | |
4417 | - | ||
4418 | void gen6_gt_check_fifodbg(struct drm_i915_private *dev_priv) |
- | |
4419 | { |
- | |
4420 | u32 gtfifodbg; |
- | |
4421 | gtfifodbg = I915_READ_NOTRACE(GTFIFODBG); |
- | |
4422 | if (WARN(gtfifodbg & GT_FIFO_CPU_ERROR_MASK, |
- | |
4423 | "MMIO read or write has been dropped %x\n", gtfifodbg)) |
- | |
4424 | I915_WRITE_NOTRACE(GTFIFODBG, GT_FIFO_CPU_ERROR_MASK); |
- | |
4425 | } |
- | |
4426 | - | ||
4427 | static void __gen6_gt_force_wake_put(struct drm_i915_private *dev_priv) |
- | |
4428 | { |
- | |
4429 | I915_WRITE_NOTRACE(FORCEWAKE, 0); |
- | |
4430 | /* something from same cacheline, but !FORCEWAKE */ |
- | |
4431 | POSTING_READ(ECOBUS); |
- | |
4432 | gen6_gt_check_fifodbg(dev_priv); |
- | |
4433 | } |
- | |
4434 | - | ||
4435 | static void __gen6_gt_force_wake_mt_put(struct drm_i915_private *dev_priv) |
- | |
4436 | { |
- | |
4437 | I915_WRITE_NOTRACE(FORCEWAKE_MT, _MASKED_BIT_DISABLE(FORCEWAKE_KERNEL)); |
- | |
4438 | /* something from same cacheline, but !FORCEWAKE_MT */ |
- | |
4439 | POSTING_READ(ECOBUS); |
- | |
4440 | gen6_gt_check_fifodbg(dev_priv); |
- | |
4441 | } |
- | |
4442 | - | ||
4443 | /* |
- | |
4444 | * see gen6_gt_force_wake_get() |
- | |
4445 | */ |
- | |
4446 | void gen6_gt_force_wake_put(struct drm_i915_private *dev_priv) |
- | |
4447 | { |
- | |
4448 | unsigned long irqflags; |
- | |
4449 | - | ||
4450 | spin_lock_irqsave(&dev_priv->gt_lock, irqflags); |
- | |
4451 | if (--dev_priv->forcewake_count == 0) |
- | |
4452 | dev_priv->gt.force_wake_put(dev_priv); |
- | |
4453 | spin_unlock_irqrestore(&dev_priv->gt_lock, irqflags); |
- | |
4454 | } |
- | |
4455 | - | ||
4456 | int __gen6_gt_wait_for_fifo(struct drm_i915_private *dev_priv) |
- | |
4457 | { |
- | |
4458 | int ret = 0; |
- | |
4459 | - | ||
4460 | if (dev_priv->gt_fifo_count < GT_FIFO_NUM_RESERVED_ENTRIES) { |
- | |
4461 | int loop = 500; |
- | |
4462 | u32 fifo = I915_READ_NOTRACE(GT_FIFO_FREE_ENTRIES); |
- | |
4463 | while (fifo <= GT_FIFO_NUM_RESERVED_ENTRIES && loop--) { |
- | |
4464 | udelay(10); |
- | |
4465 | fifo = I915_READ_NOTRACE(GT_FIFO_FREE_ENTRIES); |
- | |
4466 | } |
- | |
4467 | if (WARN_ON(loop < 0 && fifo <= GT_FIFO_NUM_RESERVED_ENTRIES)) |
- | |
4468 | ++ret; |
- | |
4469 | dev_priv->gt_fifo_count = fifo; |
- | |
4470 | } |
- | |
4471 | dev_priv->gt_fifo_count--; |
- | |
4472 | - | ||
4473 | return ret; |
- | |
4474 | } |
- | |
4475 | - | ||
4476 | static void vlv_force_wake_reset(struct drm_i915_private *dev_priv) |
- | |
4477 | { |
- | |
4478 | I915_WRITE_NOTRACE(FORCEWAKE_VLV, _MASKED_BIT_DISABLE(0xffff)); |
- | |
4479 | /* something from same cacheline, but !FORCEWAKE_VLV */ |
- | |
4480 | POSTING_READ(FORCEWAKE_ACK_VLV); |
- | |
4481 | } |
- | |
4482 | - | ||
4483 | static void vlv_force_wake_get(struct drm_i915_private *dev_priv) |
- | |
4484 | { |
- | |
4485 | if (wait_for_atomic((I915_READ_NOTRACE(FORCEWAKE_ACK_VLV) & FORCEWAKE_KERNEL) == 0, |
- | |
4486 | FORCEWAKE_ACK_TIMEOUT_MS)) |
- | |
4487 | DRM_ERROR("Timed out waiting for forcewake old ack to clear.\n"); |
- | |
4488 | - | ||
4489 | I915_WRITE_NOTRACE(FORCEWAKE_VLV, _MASKED_BIT_ENABLE(FORCEWAKE_KERNEL)); |
- | |
4490 | I915_WRITE_NOTRACE(FORCEWAKE_MEDIA_VLV, |
- | |
4491 | _MASKED_BIT_ENABLE(FORCEWAKE_KERNEL)); |
- | |
4492 | - | ||
4493 | if (wait_for_atomic((I915_READ_NOTRACE(FORCEWAKE_ACK_VLV) & FORCEWAKE_KERNEL), |
- | |
4494 | FORCEWAKE_ACK_TIMEOUT_MS)) |
- | |
4495 | DRM_ERROR("Timed out waiting for GT to ack forcewake request.\n"); |
- | |
4496 | - | ||
4497 | if (wait_for_atomic((I915_READ_NOTRACE(FORCEWAKE_ACK_MEDIA_VLV) & |
- | |
4498 | FORCEWAKE_KERNEL), |
- | |
4499 | FORCEWAKE_ACK_TIMEOUT_MS)) |
- | |
4500 | DRM_ERROR("Timed out waiting for media to ack forcewake request.\n"); |
- | |
4501 | - | ||
4502 | __gen6_gt_wait_for_thread_c0(dev_priv); |
- | |
4503 | } |
- | |
4504 | - | ||
4505 | static void vlv_force_wake_put(struct drm_i915_private *dev_priv) |
- | |
4506 | { |
- | |
4507 | I915_WRITE_NOTRACE(FORCEWAKE_VLV, _MASKED_BIT_DISABLE(FORCEWAKE_KERNEL)); |
- | |
4508 | I915_WRITE_NOTRACE(FORCEWAKE_MEDIA_VLV, |
- | |
4509 | _MASKED_BIT_DISABLE(FORCEWAKE_KERNEL)); |
- | |
4510 | /* The below doubles as a POSTING_READ */ |
- | |
4511 | gen6_gt_check_fifodbg(dev_priv); |
- | |
4512 | } |
- | |
4513 | - | ||
4514 | void intel_gt_reset(struct drm_device *dev) |
- | |
4515 | { |
- | |
4516 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | |
4517 | - | ||
4518 | if (IS_VALLEYVIEW(dev)) { |
- | |
4519 | vlv_force_wake_reset(dev_priv); |
- | |
4520 | } else if (INTEL_INFO(dev)->gen >= 6) { |
- | |
4521 | __gen6_gt_force_wake_reset(dev_priv); |
- | |
4522 | if (IS_IVYBRIDGE(dev) || IS_HASWELL(dev)) |
- | |
4523 | __gen6_gt_force_wake_mt_reset(dev_priv); |
- | |
4524 | } |
- | |
4525 | } |
- | |
4526 | - | ||
4527 | void intel_gt_init(struct drm_device *dev) |
- | |
4528 | { |
- | |
4529 | struct drm_i915_private *dev_priv = dev->dev_private; |
- | |
4530 | - | ||
4531 | spin_lock_init(&dev_priv->gt_lock); |
- | |
4532 | - | ||
4533 | intel_gt_reset(dev); |
- | |
4534 | - | ||
4535 | if (IS_VALLEYVIEW(dev)) { |
- | |
4536 | dev_priv->gt.force_wake_get = vlv_force_wake_get; |
- | |
4537 | dev_priv->gt.force_wake_put = vlv_force_wake_put; |
- | |
4538 | } else if (IS_IVYBRIDGE(dev) || IS_HASWELL(dev)) { |
- | |
4539 | dev_priv->gt.force_wake_get = __gen6_gt_force_wake_mt_get; |
- | |
4540 | dev_priv->gt.force_wake_put = __gen6_gt_force_wake_mt_put; |
- | |
4541 | } else if (IS_GEN6(dev)) { |
- | |
4542 | dev_priv->gt.force_wake_get = __gen6_gt_force_wake_get; |
- | |
4543 | dev_priv->gt.force_wake_put = __gen6_gt_force_wake_put; |
- | |
4544 | } |
- | |
4545 | INIT_DELAYED_WORK(&dev_priv->rps.delayed_resume_work, |
- | |
4546 | intel_gen6_powersave_work); |
- | |
4547 | } |
- | |
4548 | 5589 | ||
4549 | int sandybridge_pcode_read(struct drm_i915_private *dev_priv, u8 mbox, u32 *val) |
5590 | int sandybridge_pcode_read(struct drm_i915_private *dev_priv, u8 mbox, u32 *val) |
4550 | { |
5591 | { |
Line 4551... | Line 5592... | ||
4551 | WARN_ON(!mutex_is_locked(&dev_priv->rps.hw_lock)); |
5592 | WARN_ON(!mutex_is_locked(&dev_priv->rps.hw_lock)); |
Line 4591... | Line 5632... | ||
4591 | I915_WRITE(GEN6_PCODE_DATA, 0); |
5632 | I915_WRITE(GEN6_PCODE_DATA, 0); |
Line 4592... | Line 5633... | ||
4592 | 5633 | ||
4593 | return 0; |
5634 | return 0; |
Line 4594... | Line 5635... | ||
4594 | } |
5635 | } |
4595 | - | ||
4596 | static int vlv_punit_rw(struct drm_i915_private *dev_priv, u8 opcode, |
5636 | |
4597 | u8 addr, u32 *val) |
- | |
4598 | { |
- | |
4599 | u32 cmd, devfn, port, be, bar; |
- | |
4600 | 5637 | int vlv_gpu_freq(int ddr_freq, int val) |
|
4601 | bar = 0; |
- | |
4602 | be = 0xf; |
- | |
4603 | port = IOSF_PORT_PUNIT; |
- | |
4604 | devfn = PCI_DEVFN(2, 0); |
- | |
4605 | - | ||
4606 | cmd = (devfn << IOSF_DEVFN_SHIFT) | (opcode << IOSF_OPCODE_SHIFT) | |
- | |
Line 4607... | Line 5638... | ||
4607 | (port << IOSF_PORT_SHIFT) | (be << IOSF_BYTE_ENABLES_SHIFT) | |
5638 | { |
- | 5639 | int mult, base; |
|
- | 5640 | ||
- | 5641 | switch (ddr_freq) { |
|
- | 5642 | case 800: |
|
- | 5643 | mult = 20; |
|
- | 5644 | base = 120; |
|
- | 5645 | break; |
|
- | 5646 | case 1066: |
|
- | 5647 | mult = 22; |
|
- | 5648 | base = 133; |
|
- | 5649 | break; |
|
- | 5650 | case 1333: |
|
- | 5651 | mult = 21; |
|
- | 5652 | base = 125; |
|
- | 5653 | break; |
|
Line 4608... | Line -... | ||
4608 | (bar << IOSF_BAR_SHIFT); |
- | |
4609 | - | ||
4610 | WARN_ON(!mutex_is_locked(&dev_priv->rps.hw_lock)); |
5654 | default: |
4611 | - | ||
4612 | if (I915_READ(VLV_IOSF_DOORBELL_REQ) & IOSF_SB_BUSY) { |
- | |
4613 | DRM_DEBUG_DRIVER("warning: pcode (%s) mailbox access failed\n", |
5655 | return -1; |
Line 4614... | Line -... | ||
4614 | opcode == PUNIT_OPCODE_REG_READ ? |
- | |
4615 | "read" : "write"); |
5656 | } |
- | 5657 | ||
4616 | return -EAGAIN; |
5658 | return ((val - 0xbd) * mult) + base; |
4617 | } |
- | |
Line 4618... | Line 5659... | ||
4618 | 5659 | } |
|
- | 5660 | ||
- | 5661 | int vlv_freq_opcode(int ddr_freq, int val) |
|
4619 | I915_WRITE(VLV_IOSF_ADDR, addr); |
5662 | { |
- | 5663 | int mult, base; |
|
- | 5664 | ||
- | 5665 | switch (ddr_freq) { |
|
- | 5666 | case 800: |
|
- | 5667 | mult = 20; |
|
- | 5668 | base = 120; |
|
4620 | if (opcode == PUNIT_OPCODE_REG_WRITE) |
5669 | break; |
4621 | I915_WRITE(VLV_IOSF_DATA, *val); |
5670 | case 1066: |
4622 | I915_WRITE(VLV_IOSF_DOORBELL_REQ, cmd); |
5671 | mult = 22; |
- | 5672 | base = 133; |
|
4623 | 5673 | break; |
|
4624 | if (wait_for((I915_READ(VLV_IOSF_DOORBELL_REQ) & IOSF_SB_BUSY) == 0, |
5674 | case 1333: |
Line 4625... | Line 5675... | ||
4625 | 500)) { |
5675 | mult = 21; |
4626 | DRM_ERROR("timeout waiting for pcode %s (%d) to finish\n", |
5676 | base = 125; |
4627 | opcode == PUNIT_OPCODE_REG_READ ? "read" : "write", |
5677 | break; |
Line -... | Line 5678... | ||
- | 5678 | default: |
|
4628 | addr); |
5679 | return -1; |
4629 | return -ETIMEDOUT; |
- | |
Line 4630... | Line -... | ||
4630 | } |
- | |
4631 | - | ||
4632 | if (opcode == PUNIT_OPCODE_REG_READ) |
5680 | } |
4633 | *val = I915_READ(VLV_IOSF_DATA); |
5681 | |
Line 4634... | Line 5682... | ||
4634 | I915_WRITE(VLV_IOSF_DATA, 0); |
5682 | val /= mult; |
4635 | 5683 | val -= base / mult; |
|
- | 5684 | val += 0xbd; |
|
- | 5685 | ||
- | 5686 | if (val > 0xea) |
|
- | 5687 | val = 0xea; |
|
- | 5688 | ||
4636 | return 0; |
5689 | return val; |
4637 | } |
5690 | } |
- | 5691 |