From patchwork Fri Aug 14 21:34:12 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Zanoni, Paulo R" X-Patchwork-Id: 7019521 Return-Path: X-Original-To: patchwork-intel-gfx@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 0D3209F344 for ; Fri, 14 Aug 2015 21:34:46 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id DCD2B20637 for ; Fri, 14 Aug 2015 21:34:44 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) by mail.kernel.org (Postfix) with ESMTP id 75D9C2063A for ; Fri, 14 Aug 2015 21:34:43 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id D52116E8B6; Fri, 14 Aug 2015 14:34:42 -0700 (PDT) X-Original-To: intel-gfx@lists.freedesktop.org Delivered-To: intel-gfx@lists.freedesktop.org Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by gabe.freedesktop.org (Postfix) with ESMTP id D92846E730 for ; Fri, 14 Aug 2015 14:34:40 -0700 (PDT) Received: from fmsmga002.fm.intel.com ([10.253.24.26]) by orsmga101.jf.intel.com with ESMTP; 14 Aug 2015 14:34:41 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.15,680,1432623600"; d="scan'208";a="783960267" Received: from jamtsfi1-mobl1.amr.corp.intel.com (HELO panetone.amr.corp.intel.com) ([10.254.187.138]) by fmsmga002.fm.intel.com with ESMTP; 14 Aug 2015 14:34:40 -0700 From: Paulo Zanoni To: intel-gfx@lists.freedesktop.org Date: Fri, 14 Aug 2015 18:34:12 -0300 Message-Id: <1439588061-18064-8-git-send-email-paulo.r.zanoni@intel.com> X-Mailer: git-send-email 2.4.6 In-Reply-To: <1439588061-18064-1-git-send-email-paulo.r.zanoni@intel.com> References: <1439588061-18064-1-git-send-email-paulo.r.zanoni@intel.com> Subject: [Intel-gfx] [PATCH 07/16] drm/i915: disable FBC on FIFO underruns X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.18 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" X-Spam-Status: No, score=-5.2 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_MED, RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP If we want to try to enable FBC by default on any platform we need to be on the safe side and disable it in case we get an underrun while FBC is enabled on the corresponding pipe. We currently already have other reasons for FIFO underruns on our driver, but the ones I saw with FBC lead to black screens that only go away when you disable FBC. The current FIFO underrun I see happens when the CFB is using the top 8mb of stolen memory. This is reproducible with a 2560x1440 DP Monitor on a system with 32mb of stolen memory. On this case, all the IGT tests fail while checking the screen CRC. A later patch on this series will fix this problem for real. With this patch, the tests will start failing while checking if FBC is enabled instead of failing while comparing the CRC of the black screen against the correct CRC. So this patch is not hiding any IGT bugs: the tests still fail, but now they fail with a different reason. Signed-off-by: Paulo Zanoni --- drivers/gpu/drm/i915/i915_drv.h | 5 +++ drivers/gpu/drm/i915/intel_drv.h | 1 + drivers/gpu/drm/i915/intel_fbc.c | 61 ++++++++++++++++++++++++++++++ drivers/gpu/drm/i915/intel_fifo_underrun.c | 2 + 4 files changed, 69 insertions(+) diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index 4fd7858..e74a844 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -926,6 +926,11 @@ struct i915_fbc { struct drm_framebuffer *fb; } *fbc_work; + struct intel_fbc_underrun_work { + struct work_struct work; + struct intel_crtc *crtc; + } underrun_work; + enum no_fbc_reason { FBC_OK, /* FBC is enabled */ FBC_UNSUPPORTED, /* FBC is not supported by this chipset */ diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 81b7d77..246925d 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -1247,6 +1247,7 @@ void intel_fbc_flush(struct drm_i915_private *dev_priv, unsigned int frontbuffer_bits, enum fb_op_origin origin); const char *intel_no_fbc_reason_str(enum no_fbc_reason reason); void intel_fbc_cleanup_cfb(struct drm_i915_private *dev_priv); +void intel_fbc_handle_fifo_underrun(struct intel_crtc *crtc); /* intel_hdmi.c */ void intel_hdmi_init(struct drm_device *dev, int hdmi_reg, enum port port); diff --git a/drivers/gpu/drm/i915/intel_fbc.c b/drivers/gpu/drm/i915/intel_fbc.c index a63d10a..28e569c 100644 --- a/drivers/gpu/drm/i915/intel_fbc.c +++ b/drivers/gpu/drm/i915/intel_fbc.c @@ -955,6 +955,65 @@ void intel_fbc_flush(struct drm_i915_private *dev_priv, mutex_unlock(&dev_priv->fbc.lock); } +static void intel_fbc_underrun_work_fn(struct work_struct *__work) +{ + struct intel_fbc_underrun_work *work = + container_of(__work, struct intel_fbc_underrun_work, work); + struct intel_crtc *crtc = work->crtc; + struct drm_i915_private *dev_priv = crtc->base.dev->dev_private; + + mutex_lock(&dev_priv->fbc.lock); + if (!intel_fbc_enabled(dev_priv) || dev_priv->fbc.crtc != crtc) + goto out; + + DRM_DEBUG_KMS("Disabling FBC due to FIFO underrun.\n"); + i915.enable_fbc = 0; + __intel_fbc_disable(dev_priv); + +out: + work->crtc = NULL; + mutex_unlock(&dev_priv->fbc.lock); +} + +/** + * intel_fbc_handle_fifo_underrun - handle FIFO underruns if FBC is enabled + * @crtc: the CRTC that caused the underrun + * + * Although we can't know for sure what caused an underrun, one of the possible + * reasons is FBC. And on the FBC case, the user may have a black screen until + * FBC is disabled. So whenever a FIFO underrun happens while FBC is enabled, + * disable FBC just because it may help. + * + * We disable FBC by changing the i915 param, so FBC won't come back on the next + * frame just to cause another underrun. Test suites can force FBC back by + * changing the module parameter again through sysfs. + */ +void intel_fbc_handle_fifo_underrun(struct intel_crtc *crtc) +{ + struct drm_i915_private *dev_priv = crtc->base.dev->dev_private; + struct intel_fbc_underrun_work *work = &dev_priv->fbc.underrun_work; + + if (!dev_priv->fbc.enable_fbc) + return; + + /* These checks are unlocked. We can't grab the lock since we're in the + * IRQ handler. OTOH, grabbing it wouldn't help much since the underrun + * interrupt is asynchronous. Still, this a "try to recover because we + * have already failed" function, so let's at least try, and if we fail, + * we'll probably be able to try again next frame when another underrun + * happens. We'll also do the checks again in the work function, where + * we can grab the lock. */ + if (!intel_fbc_enabled(dev_priv) || dev_priv->fbc.crtc != crtc) + return; + + /* Something already scheduled it. */ + if (work->crtc != NULL) + return; + + work->crtc = crtc; + schedule_work(&work->work); +} + /** * intel_fbc_init - Initialize FBC * @dev_priv: the i915 device @@ -966,6 +1025,8 @@ void intel_fbc_init(struct drm_i915_private *dev_priv) enum pipe pipe; mutex_init(&dev_priv->fbc.lock); + INIT_WORK(&dev_priv->fbc.underrun_work.work, + intel_fbc_underrun_work_fn); if (!HAS_FBC(dev_priv)) { dev_priv->fbc.enabled = false; diff --git a/drivers/gpu/drm/i915/intel_fifo_underrun.c b/drivers/gpu/drm/i915/intel_fifo_underrun.c index 54daa66..90e60fb 100644 --- a/drivers/gpu/drm/i915/intel_fifo_underrun.c +++ b/drivers/gpu/drm/i915/intel_fifo_underrun.c @@ -356,6 +356,8 @@ void intel_cpu_fifo_underrun_irq_handler(struct drm_i915_private *dev_priv, if (intel_set_cpu_fifo_underrun_reporting(dev_priv, pipe, false)) DRM_ERROR("CPU pipe %c FIFO underrun\n", pipe_name(pipe)); + + intel_fbc_handle_fifo_underrun(to_intel_crtc(crtc)); } /**