This was done by the following semantic patch:
	@@ expression i915; @@
	- INTEL_GEN(i915)
	+ GRAPHICS_VER(i915)
	@@ expression i915; expression E; @@
	- INTEL_GEN(i915) >= E
	+ GRAPHICS_VER(i915) >= E
	@@ expression dev_priv; expression E; @@
	- !IS_GEN(dev_priv, E)
	+ GRAPHICS_VER(dev_priv) != E
	@@ expression dev_priv; expression E; @@
	- IS_GEN(dev_priv, E)
	+ GRAPHICS_VER(dev_priv) == E
	@@
	expression dev_priv;
	expression from, until;
	@@
	- IS_GEN_RANGE(dev_priv, from, until)
	+ IS_GRAPHICS_VER(dev_priv, from, until)
	@def@
	expression E;
	identifier id =~ "^gen$";
	@@
	- id = GRAPHICS_VER(E)
	+ ver = GRAPHICS_VER(E)
	@@
	identifier def.id;
	@@
	- id
	+ ver
It also takes care of renaming the variable we assign to GRAPHICS_VER()
so to use "ver" rather than "gen".
Cc: intel-gvt-dev@lists.freedesktop.org
Cc: Zhenyu Wang <zhenyuw@linux.intel.com>
Signed-off-by: Lucas De Marchi <lucas.demarchi@intel.com>
Reviewed-by: Matt Roper <matthew.d.roper@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20210603165428.3625495-5-lucas.demarchi@intel.com
 
         * update reg values in it into vregs, so LRIs in workload with
         * inhibit context will restore with correct values
         */
-       if (IS_GEN(s->engine->i915, 9) &&
+       if (GRAPHICS_VER(s->engine->i915) == 9 &&
            intel_gvt_mmio_is_sr_in_ctx(gvt, offset) &&
            !strncmp(cmd, "lri", 3)) {
                intel_gvt_hypervisor_read_gpa(s->vgpu,
        if (!info->async_flip)
                return 0;
 
-       if (INTEL_GEN(s->engine->i915) >= 9) {
+       if (GRAPHICS_VER(s->engine->i915) >= 9) {
                stride = vgpu_vreg_t(s->vgpu, info->stride_reg) & GENMASK(9, 0);
                tile = (vgpu_vreg_t(s->vgpu, info->ctrl_reg) &
                                GENMASK(12, 10)) >> 10;
 
        set_mask_bits(&vgpu_vreg_t(vgpu, info->surf_reg), GENMASK(31, 12),
                      info->surf_val << 12);
-       if (INTEL_GEN(dev_priv) >= 9) {
+       if (GRAPHICS_VER(dev_priv) >= 9) {
                set_mask_bits(&vgpu_vreg_t(vgpu, info->stride_reg), GENMASK(9, 0),
                              info->stride_val);
                set_mask_bits(&vgpu_vreg_t(vgpu, info->ctrl_reg), GENMASK(12, 10),
 {
        if (IS_BROADWELL(s->engine->i915))
                return gen8_decode_mi_display_flip(s, info);
-       if (INTEL_GEN(s->engine->i915) >= 9)
+       if (GRAPHICS_VER(s->engine->i915) >= 9)
                return skl_decode_mi_display_flip(s, info);
 
        return -ENODEV;
 
 
        obj->read_domains = I915_GEM_DOMAIN_GTT;
        obj->write_domain = 0;
-       if (INTEL_GEN(dev_priv) >= 9) {
+       if (GRAPHICS_VER(dev_priv) >= 9) {
                unsigned int tiling_mode = 0;
                unsigned int stride = 0;
 
 
        u32 stride_reg = vgpu_vreg_t(vgpu, DSPSTRIDE(pipe)) & stride_mask;
        u32 stride = stride_reg;
 
-       if (INTEL_GEN(dev_priv) >= 9) {
+       if (GRAPHICS_VER(dev_priv) >= 9) {
                switch (tiled) {
                case PLANE_CTL_TILED_LINEAR:
                        stride = stride_reg * 64;
        if (!plane->enabled)
                return -ENODEV;
 
-       if (INTEL_GEN(dev_priv) >= 9) {
+       if (GRAPHICS_VER(dev_priv) >= 9) {
                plane->tiled = val & PLANE_CTL_TILED_MASK;
                fmt = skl_format_to_drm(
                        val & PLANE_CTL_FORMAT_MASK,
        }
 
        plane->stride = intel_vgpu_get_stride(vgpu, pipe, plane->tiled,
-               (INTEL_GEN(dev_priv) >= 9) ?
-                       (_PRI_PLANE_STRIDE_MASK >> 6) :
-                               _PRI_PLANE_STRIDE_MASK, plane->bpp);
+               (GRAPHICS_VER(dev_priv) >= 9) ?
+               (_PRI_PLANE_STRIDE_MASK >> 6) :
+               _PRI_PLANE_STRIDE_MASK, plane->bpp);
 
        plane->width = (vgpu_vreg_t(vgpu, PIPESRC(pipe)) & _PIPE_H_SRCSZ_MASK) >>
                _PIPE_H_SRCSZ_SHIFT;
 
 {
        struct drm_i915_private *dev_priv = vgpu->gvt->gt->i915;
 
-       if (INTEL_GEN(dev_priv) == 9 || INTEL_GEN(dev_priv) == 10) {
+       if (GRAPHICS_VER(dev_priv) == 9 || GRAPHICS_VER(dev_priv) == 10) {
                u32 ips = vgpu_vreg_t(vgpu, GEN8_GAMW_ECO_DEV_RW_IA) &
                        GAMW_ECO_ENABLE_64K_IPS_FIELD;
 
                return ips == GAMW_ECO_ENABLE_64K_IPS_FIELD;
-       } else if (INTEL_GEN(dev_priv) >= 11) {
+       } else if (GRAPHICS_VER(dev_priv) >= 11) {
                /* 64K paging only controlled by IPS bit in PTE now. */
                return true;
        } else
 
 {
        u32 ips = (*(u32 *)p_data) & GAMW_ECO_ENABLE_64K_IPS_FIELD;
 
-       if (INTEL_GEN(vgpu->gvt->gt->i915) <= 10) {
+       if (GRAPHICS_VER(vgpu->gvt->gt->i915) <= 10) {
                if (ips == GAMW_ECO_ENABLE_64K_IPS_FIELD)
                        gvt_dbg_core("vgpu%d: ips enabled\n", vgpu->id);
                else if (!ips)
        old = vgpu_vreg(vgpu, offset);
        new = CALC_MODE_MASK_REG(old, *(u32 *)p_data);
 
-       if (INTEL_GEN(vgpu->gvt->gt->i915)  >=  9) {
+       if (GRAPHICS_VER(vgpu->gvt->gt->i915)  >=  9) {
                switch (offset) {
                case FORCEWAKE_RENDER_GEN9_REG:
                        ack_reg_offset = FORCEWAKE_ACK_RENDER_GEN9_REG;
        write_vreg(vgpu, offset, p_data, bytes);
        data = vgpu_vreg(vgpu, offset);
 
-       if ((INTEL_GEN(vgpu->gvt->gt->i915) >= 9)
+       if ((GRAPHICS_VER(vgpu->gvt->gt->i915) >= 9)
                && offset != _REG_SKL_DP_AUX_CH_CTL(port_index)) {
                /* SKL DPB/C/D aux ctl register changed */
                return 0;
 
 
                SET_BIT_INFO(irq, 4, PRIMARY_C_FLIP_DONE, INTEL_GVT_IRQ_INFO_DE_PIPE_C);
                SET_BIT_INFO(irq, 5, SPRITE_C_FLIP_DONE, INTEL_GVT_IRQ_INFO_DE_PIPE_C);
-       } else if (INTEL_GEN(gvt->gt->i915) >= 9) {
+       } else if (GRAPHICS_VER(gvt->gt->i915) >= 9) {
                SET_BIT_INFO(irq, 25, AUX_CHANNEL_B, INTEL_GVT_IRQ_INFO_DE_PORT);
                SET_BIT_INFO(irq, 26, AUX_CHANNEL_C, INTEL_GVT_IRQ_INFO_DE_PORT);
                SET_BIT_INFO(irq, 27, AUX_CHANNEL_D, INTEL_GVT_IRQ_INFO_DE_PORT);
 
         */
        fw = intel_uncore_forcewake_for_reg(uncore, reg,
                                            FW_REG_READ | FW_REG_WRITE);
-       if (engine->id == RCS0 && INTEL_GEN(engine->i915) >= 9)
+       if (engine->id == RCS0 && GRAPHICS_VER(engine->i915) >= 9)
                fw |= FORCEWAKE_RENDER;
 
        intel_uncore_forcewake_get(uncore, fw);
        if (drm_WARN_ON(&engine->i915->drm, engine->id >= ARRAY_SIZE(regs)))
                return;
 
-       if (engine->id == RCS0 && IS_GEN(engine->i915, 9))
+       if (engine->id == RCS0 && GRAPHICS_VER(engine->i915) == 9)
                return;
 
        if (!pre && !gen9_render_mocs.initialized)
        struct engine_mmio *mmio;
        u32 old_v, new_v;
 
-       if (INTEL_GEN(engine->i915) >= 9)
+       if (GRAPHICS_VER(engine->i915) >= 9)
                switch_mocs(pre, next, engine);
 
        for (mmio = engine->i915->gvt->engine_mmio_list.mmio;
                 * state image on gen9, it's initialized by lri command and
                 * save or restore with context together.
                 */
-               if (IS_GEN(engine->i915, 9) && mmio->in_context)
+               if (GRAPHICS_VER(engine->i915) == 9 && mmio->in_context)
                        continue;
 
                // save
 {
        struct engine_mmio *mmio;
 
-       if (INTEL_GEN(gvt->gt->i915) >= 9) {
+       if (GRAPHICS_VER(gvt->gt->i915) >= 9) {
                gvt->engine_mmio_list.mmio = gen9_engine_mmio_list;
                gvt->engine_mmio_list.tlb_mmio_offset_list = gen8_tlb_mmio_offset_list;
                gvt->engine_mmio_list.tlb_mmio_offset_list_cnt = ARRAY_SIZE(gen8_tlb_mmio_offset_list);
 
        u32 *cs;
        int err;
 
-       if (IS_GEN(req->engine->i915, 9) && is_inhibit_context(req->context))
+       if (GRAPHICS_VER(req->engine->i915) == 9 && is_inhibit_context(req->context))
                intel_vgpu_restore_inhibit_context(vgpu, req);
 
        /*
 static int workload_thread(void *arg)
 {
        struct intel_engine_cs *engine = arg;
-       const bool need_force_wake = INTEL_GEN(engine->i915) >= 9;
+       const bool need_force_wake = GRAPHICS_VER(engine->i915) >= 9;
        struct intel_gvt *gvt = engine->i915->gvt;
        struct intel_gvt_workload_scheduler *scheduler = &gvt->scheduler;
        struct intel_vgpu_workload *workload = NULL;
 
                gvt->types[i].avail_instance = min(low_avail / vgpu_types[i].low_mm,
                                                   high_avail / vgpu_types[i].high_mm);
 
-               if (IS_GEN(gvt->gt->i915, 8))
+               if (GRAPHICS_VER(gvt->gt->i915) == 8)
                        sprintf(gvt->types[i].name, "GVTg_V4_%s",
                                vgpu_types[i].name);
-               else if (IS_GEN(gvt->gt->i915, 9))
+               else if (GRAPHICS_VER(gvt->gt->i915) == 9)
                        sprintf(gvt->types[i].name, "GVTg_V5_%s",
                                vgpu_types[i].name);