drivers/gpu/drm/i915/display/intel_fifo_underrun.c

   1 /*
   2  * Copyright © 2014 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *    Daniel Vetter <[email protected]>
  25  *
  26  */
  27
  28 #include "i915_drv.h"
  29 #include "i915_reg.h"
  30 #include "intel_de.h"
  31 #include "intel_display_irq.h"
  32 #include "intel_display_trace.h"
  33 #include "intel_display_types.h"
  34 #include "intel_fbc.h"
  35 #include "intel_fifo_underrun.h"
  36 #include "intel_pch_display.h"
  37
  38 /**
  39  * DOC: fifo underrun handling
  40  *
  41  * The i915 driver checks for display fifo underruns using the interrupt signals
  42  * provided by the hardware. This is enabled by default and fairly useful to
  43  * debug display issues, especially watermark settings.
  44  *
  45  * If an underrun is detected this is logged into dmesg. To avoid flooding logs
  46  * and occupying the cpu underrun interrupts are disabled after the first
  47  * occurrence until the next modeset on a given pipe.
  48  *
  49  * Note that underrun detection on gmch platforms is a bit more ugly since there
  50  * is no interrupt (despite that the signalling bit is in the PIPESTAT pipe
  51  * interrupt register). Also on some other platforms underrun interrupts are
  52  * shared, which means that if we detect an underrun we need to disable underrun
  53  * reporting on all pipes.
  54  *
  55  * The code also supports underrun detection on the PCH transcoder.
  56  */
  57
  58 static bool ivb_can_enable_err_int(struct drm_device *dev)
  59 {
  60         struct drm_i915_private *dev_priv = to_i915(dev);
  61         struct intel_crtc *crtc;
  62         enum pipe pipe;
  63
  64         lockdep_assert_held(&dev_priv->irq_lock);
  65
  66         for_each_pipe(dev_priv, pipe) {
  67                 crtc = intel_crtc_for_pipe(dev_priv, pipe);
  68
  69                 if (crtc->cpu_fifo_underrun_disabled)
  70                         return false;
  71         }
  72
  73         return true;
  74 }
  75
  76 static bool cpt_can_enable_serr_int(struct drm_device *dev)
  77 {
  78         struct drm_i915_private *dev_priv = to_i915(dev);
  79         enum pipe pipe;
  80         struct intel_crtc *crtc;
  81
  82         lockdep_assert_held(&dev_priv->irq_lock);
  83
  84         for_each_pipe(dev_priv, pipe) {
  85                 crtc = intel_crtc_for_pipe(dev_priv, pipe);
  86
  87                 if (crtc->pch_fifo_underrun_disabled)
  88                         return false;
  89         }
  90
  91         return true;
  92 }
  93
  94 static void i9xx_check_fifo_underruns(struct intel_crtc *crtc)
  95 {
  96         struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
  97         i915_reg_t reg = PIPESTAT(crtc->pipe);
  98         u32 enable_mask;
  99
 100         lockdep_assert_held(&dev_priv->irq_lock);
 101
 102         if ((intel_de_read(dev_priv, reg) & PIPE_FIFO_UNDERRUN_STATUS) == 0)
 103                 return;
 104
 105         enable_mask = i915_pipestat_enable_mask(dev_priv, crtc->pipe);
 106         intel_de_write(dev_priv, reg, enable_mask | PIPE_FIFO_UNDERRUN_STATUS);
 107         intel_de_posting_read(dev_priv, reg);
 108
 109         trace_intel_cpu_fifo_underrun(dev_priv, crtc->pipe);
 110         drm_err(&dev_priv->drm, "pipe %c underrun\n", pipe_name(crtc->pipe));
 111 }
 112
 113 static void i9xx_set_fifo_underrun_reporting(struct drm_device *dev,
 114                                              enum pipe pipe,
 115                                              bool enable, bool old)
 116 {
 117         struct drm_i915_private *dev_priv = to_i915(dev);
 118         i915_reg_t reg = PIPESTAT(pipe);
 119
 120         lockdep_assert_held(&dev_priv->irq_lock);
 121
 122         if (enable) {
 123                 u32 enable_mask = i915_pipestat_enable_mask(dev_priv, pipe);
 124
 125                 intel_de_write(dev_priv, reg,
 126                                enable_mask | PIPE_FIFO_UNDERRUN_STATUS);
 127                 intel_de_posting_read(dev_priv, reg);
 128         } else {
 129                 if (old && intel_de_read(dev_priv, reg) & PIPE_FIFO_UNDERRUN_STATUS)
 130                         drm_err(&dev_priv->drm, "pipe %c underrun\n",
 131                                 pipe_name(pipe));
 132         }
 133 }
 134
 135 static void ilk_set_fifo_underrun_reporting(struct drm_device *dev,
 136                                             enum pipe pipe, bool enable)
 137 {
 138         struct drm_i915_private *dev_priv = to_i915(dev);
 139         u32 bit = (pipe == PIPE_A) ?
 140                 DE_PIPEA_FIFO_UNDERRUN : DE_PIPEB_FIFO_UNDERRUN;
 141
 142         if (enable)
 143                 ilk_enable_display_irq(dev_priv, bit);
 144         else
 145                 ilk_disable_display_irq(dev_priv, bit);
 146 }
 147
 148 static void ivb_check_fifo_underruns(struct intel_crtc *crtc)
 149 {
 150         struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
 151         enum pipe pipe = crtc->pipe;
 152         u32 err_int = intel_de_read(dev_priv, GEN7_ERR_INT);
 153
 154         lockdep_assert_held(&dev_priv->irq_lock);
 155
 156         if ((err_int & ERR_INT_FIFO_UNDERRUN(pipe)) == 0)
 157                 return;
 158
 159         intel_de_write(dev_priv, GEN7_ERR_INT, ERR_INT_FIFO_UNDERRUN(pipe));
 160         intel_de_posting_read(dev_priv, GEN7_ERR_INT);
 161
 162         trace_intel_cpu_fifo_underrun(dev_priv, pipe);
 163         drm_err(&dev_priv->drm, "fifo underrun on pipe %c\n", pipe_name(pipe));
 164 }
 165
 166 static void ivb_set_fifo_underrun_reporting(struct drm_device *dev,
 167                                             enum pipe pipe, bool enable,
 168                                             bool old)
 169 {
 170         struct drm_i915_private *dev_priv = to_i915(dev);
 171         if (enable) {
 172                 intel_de_write(dev_priv, GEN7_ERR_INT,
 173                                ERR_INT_FIFO_UNDERRUN(pipe));
 174
 175                 if (!ivb_can_enable_err_int(dev))
 176                         return;
 177
 178                 ilk_enable_display_irq(dev_priv, DE_ERR_INT_IVB);
 179         } else {
 180                 ilk_disable_display_irq(dev_priv, DE_ERR_INT_IVB);
 181
 182                 if (old &&
 183                     intel_de_read(dev_priv, GEN7_ERR_INT) & ERR_INT_FIFO_UNDERRUN(pipe)) {
 184                         drm_err(&dev_priv->drm,
 185                                 "uncleared fifo underrun on pipe %c\n",
 186                                 pipe_name(pipe));
 187                 }
 188         }
 189 }
 190
 191 static u32
 192 icl_pipe_status_underrun_mask(struct drm_i915_private *dev_priv)
 193 {
 194         u32 mask = PIPE_STATUS_UNDERRUN;
 195
 196         if (DISPLAY_VER(dev_priv) >= 13)
 197                 mask |= PIPE_STATUS_SOFT_UNDERRUN_XELPD |
 198                         PIPE_STATUS_HARD_UNDERRUN_XELPD |
 199                         PIPE_STATUS_PORT_UNDERRUN_XELPD;
 200
 201         return mask;
 202 }
 203
 204 static void bdw_set_fifo_underrun_reporting(struct drm_device *dev,
 205                                             enum pipe pipe, bool enable)
 206 {
 207         struct drm_i915_private *dev_priv = to_i915(dev);
 208         u32 mask = gen8_de_pipe_underrun_mask(dev_priv);
 209
 210         if (enable) {
 211                 if (DISPLAY_VER(dev_priv) >= 11)
 212                         intel_de_write(dev_priv, ICL_PIPESTATUS(pipe),
 213                                        icl_pipe_status_underrun_mask(dev_priv));
 214
 215                 bdw_enable_pipe_irq(dev_priv, pipe, mask);
 216         } else {
 217                 bdw_disable_pipe_irq(dev_priv, pipe, mask);
 218         }
 219 }
 220
 221 static void ibx_set_fifo_underrun_reporting(struct drm_device *dev,
 222                                             enum pipe pch_transcoder,
 223                                             bool enable)
 224 {
 225         struct drm_i915_private *dev_priv = to_i915(dev);
 226         u32 bit = (pch_transcoder == PIPE_A) ?
 227                 SDE_TRANSA_FIFO_UNDER : SDE_TRANSB_FIFO_UNDER;
 228
 229         if (enable)
 230                 ibx_enable_display_interrupt(dev_priv, bit);
 231         else
 232                 ibx_disable_display_interrupt(dev_priv, bit);
 233 }
 234
 235 static void cpt_check_pch_fifo_underruns(struct intel_crtc *crtc)
 236 {
 237         struct drm_i915_private *dev_priv = to_i915(crtc->base.dev);
 238         enum pipe pch_transcoder = crtc->pipe;
 239         u32 serr_int = intel_de_read(dev_priv, SERR_INT);
 240
 241         lockdep_assert_held(&dev_priv->irq_lock);
 242
 243         if ((serr_int & SERR_INT_TRANS_FIFO_UNDERRUN(pch_transcoder)) == 0)
 244                 return;
 245
 246         intel_de_write(dev_priv, SERR_INT,
 247                        SERR_INT_TRANS_FIFO_UNDERRUN(pch_transcoder));
 248         intel_de_posting_read(dev_priv, SERR_INT);
 249
 250         trace_intel_pch_fifo_underrun(dev_priv, pch_transcoder);
 251         drm_err(&dev_priv->drm, "pch fifo underrun on pch transcoder %c\n",
 252                 pipe_name(pch_transcoder));
 253 }
 254
 255 static void cpt_set_fifo_underrun_reporting(struct drm_device *dev,
 256                                             enum pipe pch_transcoder,
 257                                             bool enable, bool old)
 258 {
 259         struct drm_i915_private *dev_priv = to_i915(dev);
 260
 261         if (enable) {
 262                 intel_de_write(dev_priv, SERR_INT,
 263                                SERR_INT_TRANS_FIFO_UNDERRUN(pch_transcoder));
 264
 265                 if (!cpt_can_enable_serr_int(dev))
 266                         return;
 267
 268                 ibx_enable_display_interrupt(dev_priv, SDE_ERROR_CPT);
 269         } else {
 270                 ibx_disable_display_interrupt(dev_priv, SDE_ERROR_CPT);
 271
 272                 if (old && intel_de_read(dev_priv, SERR_INT) &
 273                     SERR_INT_TRANS_FIFO_UNDERRUN(pch_transcoder)) {
 274                         drm_err(&dev_priv->drm,
 275                                 "uncleared pch fifo underrun on pch transcoder %c\n",
 276                                 pipe_name(pch_transcoder));
 277                 }
 278         }
 279 }
 280
 281 static bool __intel_set_cpu_fifo_underrun_reporting(struct drm_device *dev,
 282                                                     enum pipe pipe, bool enable)
 283 {
 284         struct drm_i915_private *dev_priv = to_i915(dev);
 285         struct intel_crtc *crtc = intel_crtc_for_pipe(dev_priv, pipe);
 286         bool old;
 287
 288         lockdep_assert_held(&dev_priv->irq_lock);
 289
 290         old = !crtc->cpu_fifo_underrun_disabled;
 291         crtc->cpu_fifo_underrun_disabled = !enable;
 292
 293         if (HAS_GMCH(dev_priv))
 294                 i9xx_set_fifo_underrun_reporting(dev, pipe, enable, old);
 295         else if (IS_IRONLAKE(dev_priv) || IS_SANDYBRIDGE(dev_priv))
 296                 ilk_set_fifo_underrun_reporting(dev, pipe, enable);
 297         else if (DISPLAY_VER(dev_priv) == 7)
 298                 ivb_set_fifo_underrun_reporting(dev, pipe, enable, old);
 299         else if (DISPLAY_VER(dev_priv) >= 8)
 300                 bdw_set_fifo_underrun_reporting(dev, pipe, enable);
 301
 302         return old;
 303 }
 304
 305 /**
 306  * intel_set_cpu_fifo_underrun_reporting - set cpu fifo underrrun reporting state
 307  * @dev_priv: i915 device instance
 308  * @pipe: (CPU) pipe to set state for
 309  * @enable: whether underruns should be reported or not
 310  *
 311  * This function sets the fifo underrun state for @pipe. It is used in the
 312  * modeset code to avoid false positives since on many platforms underruns are
 313  * expected when disabling or enabling the pipe.
 314  *
 315  * Notice that on some platforms disabling underrun reports for one pipe
 316  * disables for all due to shared interrupts. Actual reporting is still per-pipe
 317  * though.
 318  *
 319  * Returns the previous state of underrun reporting.
 320  */
 321 bool intel_set_cpu_fifo_underrun_reporting(struct drm_i915_private *dev_priv,
 322                                            enum pipe pipe, bool enable)
 323 {
 324         unsigned long flags;
 325         bool ret;
 326
 327         spin_lock_irqsave(&dev_priv->irq_lock, flags);
 328         ret = __intel_set_cpu_fifo_underrun_reporting(&dev_priv->drm, pipe,
 329                                                       enable);
 330         spin_unlock_irqrestore(&dev_priv->irq_lock, flags);
 331
 332         return ret;
 333 }
 334
 335 /**
 336  * intel_set_pch_fifo_underrun_reporting - set PCH fifo underrun reporting state
 337  * @dev_priv: i915 device instance
 338  * @pch_transcoder: the PCH transcoder (same as pipe on IVB and older)
 339  * @enable: whether underruns should be reported or not
 340  *
 341  * This function makes us disable or enable PCH fifo underruns for a specific
 342  * PCH transcoder. Notice that on some PCHs (e.g. CPT/PPT), disabling FIFO
 343  * underrun reporting for one transcoder may also disable all the other PCH
 344  * error interruts for the other transcoders, due to the fact that there's just
 345  * one interrupt mask/enable bit for all the transcoders.
 346  *
 347  * Returns the previous state of underrun reporting.
 348  */
 349 bool intel_set_pch_fifo_underrun_reporting(struct drm_i915_private *dev_priv,
 350                                            enum pipe pch_transcoder,
 351                                            bool enable)
 352 {
 353         struct intel_crtc *crtc =
 354                 intel_crtc_for_pipe(dev_priv, pch_transcoder);
 355         unsigned long flags;
 356         bool old;
 357
 358         /*
 359          * NOTE: Pre-LPT has a fixed cpu pipe -> pch transcoder mapping, but LPT
 360          * has only one pch transcoder A that all pipes can use. To avoid racy
 361          * pch transcoder -> pipe lookups from interrupt code simply store the
 362          * underrun statistics in crtc A. Since we never expose this anywhere
 363          * nor use it outside of the fifo underrun code here using the "wrong"
 364          * crtc on LPT won't cause issues.
 365          */
 366
 367         spin_lock_irqsave(&dev_priv->irq_lock, flags);
 368
 369         old = !crtc->pch_fifo_underrun_disabled;
 370         crtc->pch_fifo_underrun_disabled = !enable;
 371
 372         if (HAS_PCH_IBX(dev_priv))
 373                 ibx_set_fifo_underrun_reporting(&dev_priv->drm,
 374                                                 pch_transcoder,
 375                                                 enable);
 376         else
 377                 cpt_set_fifo_underrun_reporting(&dev_priv->drm,
 378                                                 pch_transcoder,
 379                                                 enable, old);
 380
 381         spin_unlock_irqrestore(&dev_priv->irq_lock, flags);
 382         return old;
 383 }
 384
 385 /**
 386  * intel_cpu_fifo_underrun_irq_handler - handle CPU fifo underrun interrupt
 387  * @dev_priv: i915 device instance
 388  * @pipe: (CPU) pipe to set state for
 389  *
 390  * This handles a CPU fifo underrun interrupt, generating an underrun warning
 391  * into dmesg if underrun reporting is enabled and then disables the underrun
 392  * interrupt to avoid an irq storm.
 393  */
 394 void intel_cpu_fifo_underrun_irq_handler(struct drm_i915_private *dev_priv,
 395                                          enum pipe pipe)
 396 {
 397         struct intel_crtc *crtc = intel_crtc_for_pipe(dev_priv, pipe);
 398         u32 underruns = 0;
 399
 400         /* We may be called too early in init, thanks BIOS! */
 401         if (crtc == NULL)
 402                 return;
 403
 404         /* GMCH can't disable fifo underruns, filter them. */
 405         if (HAS_GMCH(dev_priv) &&
 406             crtc->cpu_fifo_underrun_disabled)
 407                 return;
 408
 409         /*
 410          * Starting with display version 11, the PIPE_STAT register records
 411          * whether an underrun has happened, and on XELPD+, it will also record
 412          * whether the underrun was soft/hard and whether it was triggered by
 413          * the downstream port logic.  We should clear these bits (which use
 414          * write-1-to-clear logic) too.
 415          *
 416          * Note that although the IIR gives us the same underrun and soft/hard
 417          * information, PIPE_STAT is the only place we can find out whether
 418          * the underrun was caused by the downstream port.
 419          */
 420         if (DISPLAY_VER(dev_priv) >= 11) {
 421                 underruns = intel_de_read(dev_priv, ICL_PIPESTATUS(pipe)) &
 422                         icl_pipe_status_underrun_mask(dev_priv);
 423                 intel_de_write(dev_priv, ICL_PIPESTATUS(pipe), underruns);
 424         }
 425
 426         if (intel_set_cpu_fifo_underrun_reporting(dev_priv, pipe, false)) {
 427                 trace_intel_cpu_fifo_underrun(dev_priv, pipe);
 428
 429                 if (DISPLAY_VER(dev_priv) >= 11)
 430                         drm_err(&dev_priv->drm, "CPU pipe %c FIFO underrun: %s%s%s%s\n",
 431                                 pipe_name(pipe),
 432                                 underruns & PIPE_STATUS_SOFT_UNDERRUN_XELPD ? "soft," : "",
 433                                 underruns & PIPE_STATUS_HARD_UNDERRUN_XELPD ? "hard," : "",
 434                                 underruns & PIPE_STATUS_PORT_UNDERRUN_XELPD ? "port," : "",
 435                                 underruns & PIPE_STATUS_UNDERRUN ? "transcoder," : "");
 436                 else
 437                         drm_err(&dev_priv->drm, "CPU pipe %c FIFO underrun\n", pipe_name(pipe));
 438         }
 439
 440         intel_fbc_handle_fifo_underrun_irq(dev_priv);
 441 }
 442
 443 /**
 444  * intel_pch_fifo_underrun_irq_handler - handle PCH fifo underrun interrupt
 445  * @dev_priv: i915 device instance
 446  * @pch_transcoder: the PCH transcoder (same as pipe on IVB and older)
 447  *
 448  * This handles a PCH fifo underrun interrupt, generating an underrun warning
 449  * into dmesg if underrun reporting is enabled and then disables the underrun
 450  * interrupt to avoid an irq storm.
 451  */
 452 void intel_pch_fifo_underrun_irq_handler(struct drm_i915_private *dev_priv,
 453                                          enum pipe pch_transcoder)
 454 {
 455         if (intel_set_pch_fifo_underrun_reporting(dev_priv, pch_transcoder,
 456                                                   false)) {
 457                 trace_intel_pch_fifo_underrun(dev_priv, pch_transcoder);
 458                 drm_err(&dev_priv->drm, "PCH transcoder %c FIFO underrun\n",
 459                         pipe_name(pch_transcoder));
 460         }
 461 }
 462
 463 /**
 464  * intel_check_cpu_fifo_underruns - check for CPU fifo underruns immediately
 465  * @dev_priv: i915 device instance
 466  *
 467  * Check for CPU fifo underruns immediately. Useful on IVB/HSW where the shared
 468  * error interrupt may have been disabled, and so CPU fifo underruns won't
 469  * necessarily raise an interrupt, and on GMCH platforms where underruns never
 470  * raise an interrupt.
 471  */
 472 void intel_check_cpu_fifo_underruns(struct drm_i915_private *dev_priv)
 473 {
 474         struct intel_crtc *crtc;
 475
 476         spin_lock_irq(&dev_priv->irq_lock);
 477
 478         for_each_intel_crtc(&dev_priv->drm, crtc) {
 479                 if (crtc->cpu_fifo_underrun_disabled)
 480                         continue;
 481
 482                 if (HAS_GMCH(dev_priv))
 483                         i9xx_check_fifo_underruns(crtc);
 484                 else if (DISPLAY_VER(dev_priv) == 7)
 485                         ivb_check_fifo_underruns(crtc);
 486         }
 487
 488         spin_unlock_irq(&dev_priv->irq_lock);
 489 }
 490
 491 /**
 492  * intel_check_pch_fifo_underruns - check for PCH fifo underruns immediately
 493  * @dev_priv: i915 device instance
 494  *
 495  * Check for PCH fifo underruns immediately. Useful on CPT/PPT where the shared
 496  * error interrupt may have been disabled, and so PCH fifo underruns won't
 497  * necessarily raise an interrupt.
 498  */
 499 void intel_check_pch_fifo_underruns(struct drm_i915_private *dev_priv)
 500 {
 501         struct intel_crtc *crtc;
 502
 503         spin_lock_irq(&dev_priv->irq_lock);
 504
 505         for_each_intel_crtc(&dev_priv->drm, crtc) {
 506                 if (crtc->pch_fifo_underrun_disabled)
 507                         continue;
 508
 509                 if (HAS_PCH_CPT(dev_priv))
 510                         cpt_check_pch_fifo_underruns(crtc);
 511         }
 512
 513         spin_unlock_irq(&dev_priv->irq_lock);
 514 }
 515
 516 void intel_init_fifo_underrun_reporting(struct drm_i915_private *i915,
 517                                         struct intel_crtc *crtc,
 518                                         bool enable)
 519 {
 520         crtc->cpu_fifo_underrun_disabled = !enable;
 521
 522         /*
 523          * We track the PCH trancoder underrun reporting state
 524          * within the crtc. With crtc for pipe A housing the underrun
 525          * reporting state for PCH transcoder A, crtc for pipe B housing
 526          * it for PCH transcoder B, etc. LPT-H has only PCH transcoder A,
 527          * and marking underrun reporting as disabled for the non-existing
 528          * PCH transcoders B and C would prevent enabling the south
 529          * error interrupt (see cpt_can_enable_serr_int()).
 530          */
 531         if (intel_has_pch_trancoder(i915, crtc->pipe))
 532                 crtc->pch_fifo_underrun_disabled = !enable;
 533 }