#include "intel_panel.h"
 #include "intel_pci_config.h"
 #include "intel_pps.h"
+#include "intel_quirks.h"
 
 /**
  * scale - scale values from one range to another
                return val;
 
        if (dev_priv->params.invert_brightness > 0 ||
-           dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS) {
+           intel_has_quirk(dev_priv, QUIRK_INVERT_BRIGHTNESS)) {
                return panel->backlight.pwm_level_max - val + panel->backlight.pwm_level_min;
        }
 
                         panel->backlight.max == 0 || panel->backlight.pwm_level_max == 0);
 
        if (dev_priv->params.invert_brightness > 0 ||
-           (dev_priv->params.invert_brightness == 0 && dev_priv->quirks & QUIRK_INVERT_BRIGHTNESS))
+           (dev_priv->params.invert_brightness == 0 && intel_has_quirk(dev_priv, QUIRK_INVERT_BRIGHTNESS)))
                val = panel->backlight.pwm_level_max - (val - panel->backlight.pwm_level_min);
 
        return scale(val, panel->backlight.pwm_level_min, panel->backlight.pwm_level_max,
        int ret;
 
        if (!connector->panel.vbt.backlight.present) {
-               if (dev_priv->quirks & QUIRK_BACKLIGHT_PRESENT) {
+               if (intel_has_quirk(dev_priv, QUIRK_BACKLIGHT_PRESENT)) {
                        drm_dbg_kms(&dev_priv->drm,
                                    "no backlight present per VBT, but present per quirk\n");
                } else {
                if (intel_dp_aux_init_backlight_funcs(connector) == 0)
                        return;
 
-               if (!(dev_priv->quirks & QUIRK_NO_PPS_BACKLIGHT_POWER_HOOK))
+               if (!intel_has_quirk(dev_priv, QUIRK_NO_PPS_BACKLIGHT_POWER_HOOK))
                        connector->panel.backlight.power = intel_pps_backlight_power;
        }
 
 
 #include "intel_lspcon.h"
 #include "intel_pps.h"
 #include "intel_psr.h"
+#include "intel_quirks.h"
 #include "intel_snps_phy.h"
 #include "intel_sprite.h"
 #include "intel_tc.h"
 
        intel_de_write(dev_priv, TRANS_DDI_FUNC_CTL(cpu_transcoder), ctl);
 
-       if (dev_priv->quirks & QUIRK_INCREASE_DDI_DISABLED_TIME &&
+       if (intel_has_quirk(dev_priv, QUIRK_INCREASE_DDI_DISABLED_TIME) &&
            intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) {
                drm_dbg_kms(&dev_priv->drm,
                            "Quirk Increase DDI disabled time\n");
 
 #include "intel_display_types.h"
 #include "intel_drrs.h"
 #include "intel_panel.h"
+#include "intel_quirks.h"
 
 bool intel_panel_use_ssc(struct drm_i915_private *i915)
 {
        if (i915->params.panel_use_ssc >= 0)
                return i915->params.panel_use_ssc != 0;
-       return i915->display.vbt.lvds_use_ssc
-               && !(i915->quirks & QUIRK_LVDS_SSC_DISABLE);
+       return i915->display.vbt.lvds_use_ssc &&
+               !intel_has_quirk(i915, QUIRK_LVDS_SSC_DISABLE);
 }
 
 const struct drm_display_mode *
 
 #include "intel_dpll.h"
 #include "intel_lvds.h"
 #include "intel_pps.h"
+#include "intel_quirks.h"
 
 static void vlv_steal_power_sequencer(struct drm_i915_private *dev_priv,
                                      enum pipe pipe);
         * just fails to power back on. Increasing the delay to 800ms
         * seems sufficient to avoid this problem.
         */
-       if (dev_priv->quirks & QUIRK_INCREASE_T12_DELAY) {
+       if (intel_has_quirk(dev_priv, QUIRK_INCREASE_T12_DELAY)) {
                vbt->t11_t12 = max_t(u16, vbt->t11_t12, 1300 * 10);
                drm_dbg_kms(&dev_priv->drm,
                            "Increasing T12 panel delay as per the quirk to %d\n",
 
                        intel_dmi_quirks[i].hook(i915);
        }
 }
+
+bool intel_has_quirk(struct drm_i915_private *i915, unsigned long quirk)
+{
+       return i915->quirks & quirk;
+}
 
 #ifndef __INTEL_QUIRKS_H__
 #define __INTEL_QUIRKS_H__
 
+#include <linux/types.h>
+
 struct drm_i915_private;
 
-void intel_init_quirks(struct drm_i915_private *dev_priv);
+void intel_init_quirks(struct drm_i915_private *i915);
+bool intel_has_quirk(struct drm_i915_private *i915, unsigned long quirk);
 
 #endif /* __INTEL_QUIRKS_H__ */