return PTR_ERR(crtc_state);
 
        ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, true);
        if (ret != 0)
                return ret;
 
                        return -EINVAL;
                return drm_atomic_helper_check_plane_state(new_plane_state,
                                                           crtc_state,
-                                                          DRM_PLANE_HELPER_NO_SCALING,
-                                                          DRM_PLANE_HELPER_NO_SCALING,
+                                                          DRM_PLANE_NO_SCALING,
+                                                          DRM_PLANE_NO_SCALING,
                                                           false, true);
        }
 
 
                                                   new_plane_state->crtc);
 
        ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, true);
        if (ret)
                return ret;
                                                   new_plane_state->crtc);
 
        ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  true, true);
        if (ret)
                return ret;
 
        ret = drm_plane_helper_check_update(plane, crtc, fb,
                                            &src, &dest,
                                            DRM_MODE_ROTATE_0,
-                                           DRM_PLANE_HELPER_NO_SCALING,
-                                           DRM_PLANE_HELPER_NO_SCALING,
+                                           DRM_PLANE_NO_SCALING,
+                                           DRM_PLANE_NO_SCALING,
                                            false, false, &visible);
        if (ret)
                return ret;
 
                                                   &pipe->crtc);
 
        ret = drm_atomic_helper_check_plane_state(plane_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, false);
        if (ret)
                return ret;
 
                return ret;
 
        ret = intel_atomic_plane_check_clipping(plane_state, crtc_state,
-                                               DRM_PLANE_HELPER_NO_SCALING,
-                                               DRM_PLANE_HELPER_NO_SCALING,
+                                               DRM_PLANE_NO_SCALING,
+                                               DRM_PLANE_NO_SCALING,
                                                i9xx_plane_has_windowing(plane));
        if (ret)
                return ret;
 
        }
 
        ret = intel_atomic_plane_check_clipping(plane_state, crtc_state,
-                                               DRM_PLANE_HELPER_NO_SCALING,
-                                               DRM_PLANE_HELPER_NO_SCALING,
+                                               DRM_PLANE_NO_SCALING,
+                                               DRM_PLANE_NO_SCALING,
                                                true);
        if (ret)
                return ret;
 
 {
        struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
-       int min_scale = DRM_PLANE_HELPER_NO_SCALING;
-       int max_scale = DRM_PLANE_HELPER_NO_SCALING;
+       int min_scale = DRM_PLANE_NO_SCALING;
+       int max_scale = DRM_PLANE_NO_SCALING;
        int ret;
 
        if (g4x_fb_scalable(plane_state->hw.fb)) {
                return ret;
 
        ret = intel_atomic_plane_check_clipping(plane_state, crtc_state,
-                                               DRM_PLANE_HELPER_NO_SCALING,
-                                               DRM_PLANE_HELPER_NO_SCALING,
+                                               DRM_PLANE_NO_SCALING,
+                                               DRM_PLANE_NO_SCALING,
                                                true);
        if (ret)
                return ret;
 
        struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *dev_priv = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
-       int min_scale = DRM_PLANE_HELPER_NO_SCALING;
-       int max_scale = DRM_PLANE_HELPER_NO_SCALING;
+       int min_scale = DRM_PLANE_NO_SCALING;
+       int max_scale = DRM_PLANE_NO_SCALING;
        int ret;
 
        ret = skl_plane_check_fb(crtc_state, plane_state);
 
                return -EINVAL;
 
        ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  can_position, true);
        if (ret)
                return ret;
 
                return PTR_ERR(priv_state);
 
        ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  priv->soc_info->has_osd,
                                                  true);
        if (ret)
 
                                                   new_plane_state->crtc);
        return drm_atomic_helper_check_plane_state(new_plane_state,
                                                   crtc_state,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
                                                   can_position, true);
 }
 
 
                }
        }
 
-       min_scale = DRM_PLANE_HELPER_NO_SCALING;
-       max_scale = DRM_PLANE_HELPER_NO_SCALING;
+       min_scale = DRM_PLANE_NO_SCALING;
+       max_scale = DRM_PLANE_NO_SCALING;
 
        can_position = (drm_plane->type == DRM_PLANE_TYPE_OVERLAY &&
                        layer->index != (logicvc->config.layers_count - 1) &&
 
                crtc_state = new_plane_state->crtc->state;
 
        return drm_atomic_helper_check_plane_state(plane->state, crtc_state,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
                                                   true, true);
 }
 
 
        return drm_atomic_helper_check_plane_state(new_plane_state,
                                                   crtc_state,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
                                                   true, true);
 }
 
 
        return drm_atomic_helper_check_plane_state(new_plane_state,
                                                   crtc_state,
                                                   FRAC_16_16(1, 5),
-                                                  DRM_PLANE_HELPER_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
                                                   false, true);
 }
 
 
                                                   &lcdif->crtc);
 
        return drm_atomic_helper_check_plane_state(plane_state, crtc_state,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
                                                   false, true);
 }
 
 
                                                   &mxsfb->crtc);
 
        return drm_atomic_helper_check_plane_state(plane_state, crtc_state,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
                                                   false, true);
 }
 
 
        int ret;
 
        ret = drm_atomic_helper_check_plane_state(&asyw->state, &asyh->state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, true);
        if (ret)
                return ret;
 
        int ret;
 
        ret = drm_atomic_helper_check_plane_state(&asyw->state, &asyh->state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  true, true);
        asyh->curs.visible = asyw->state.visible;
        if (ret || !asyh->curs.visible)
 
        int ret;
 
        ret = drm_atomic_helper_check_plane_state(&asyw->state, &asyh->state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  true, true);
        if (ret)
                return ret;
 
                 struct nv50_head_atom *asyh)
 {
        return drm_atomic_helper_check_plane_state(&asyw->state, &asyh->state,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
                                                   true, true);
 }
 
 
                return PTR_ERR(crtc_state);
 
        ret = drm_atomic_helper_check_plane_state(state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  true, true);
        if (ret < 0)
                return ret;
 
        const struct vop_win_data *win = vop_win->data;
        int ret;
        int min_scale = win->phy->scl ? FRAC_16_16(1, 8) :
-                                       DRM_PLANE_HELPER_NO_SCALING;
+                                       DRM_PLANE_NO_SCALING;
        int max_scale = win->phy->scl ? FRAC_16_16(8, 1) :
-                                       DRM_PLANE_HELPER_NO_SCALING;
+                                       DRM_PLANE_NO_SCALING;
 
        if (!crtc || WARN_ON(!fb))
                return 0;
        struct vop_win *vop_win = to_vop_win(plane);
        const struct vop_win_data *win = vop_win->data;
        int min_scale = win->phy->scl ? FRAC_16_16(1, 8) :
-                                       DRM_PLANE_HELPER_NO_SCALING;
+                                       DRM_PLANE_NO_SCALING;
        int max_scale = win->phy->scl ? FRAC_16_16(8, 1) :
-                                       DRM_PLANE_HELPER_NO_SCALING;
+                                       DRM_PLANE_NO_SCALING;
        struct drm_crtc_state *crtc_state;
 
        if (plane != new_plane_state->crtc->cursor)
 
                return PTR_ERR(crtc_state);
 
        return drm_atomic_helper_check_plane_state(plane_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  true, true);
 }
 
 
        if (WARN_ON(!crtc_state))
                return -EINVAL;
 
-       min_scale = DRM_PLANE_HELPER_NO_SCALING;
-       max_scale = DRM_PLANE_HELPER_NO_SCALING;
+       min_scale = DRM_PLANE_NO_SCALING;
+       max_scale = DRM_PLANE_NO_SCALING;
 
        if (layer->mixer->cfg->scaler_mask & BIT(layer->channel)) {
                min_scale = SUN8I_UI_SCALER_SCALE_MIN;
 
        if (WARN_ON(!crtc_state))
                return -EINVAL;
 
-       min_scale = DRM_PLANE_HELPER_NO_SCALING;
-       max_scale = DRM_PLANE_HELPER_NO_SCALING;
+       min_scale = DRM_PLANE_NO_SCALING;
+       max_scale = DRM_PLANE_NO_SCALING;
 
        if (layer->mixer->cfg->scaler_mask & BIT(layer->channel)) {
                min_scale = SUN8I_VI_SCALER_SCALE_MIN;
 
        set_src(&plane_state, 0, 0, fb.width << 16, fb.height << 16);
        set_crtc(&plane_state, 0, 0, fb.width, fb.height);
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, false);
        KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Simple clipping check should pass\n");
        KUNIT_EXPECT_TRUE(test, plane_state.visible);
        /* Rotated clipping + reflection, no scaling. */
        plane_state.rotation = DRM_MODE_ROTATE_90 | DRM_MODE_REFLECT_X;
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, false);
        KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Rotated clipping check should pass\n");
        KUNIT_EXPECT_TRUE(test, plane_state.visible);
        set_src(&plane_state, 0, 0, 1023 << 16, 767 << 16);
        set_crtc(&plane_state, 0, 0, 1023, 767);
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, false);
        KUNIT_EXPECT_TRUE_MSG(test, ret,
                              "Should not be able to position on the crtc with can_position=false\n");
 
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  true, false);
        KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Simple positioning should work\n");
        KUNIT_EXPECT_TRUE(test, plane_state.visible);
        set_crtc(&plane_state, 0, 0, 1024, 768);
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
                                                  0x8001,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, false);
        KUNIT_EXPECT_TRUE_MSG(test, ret, "Upscaling out of range should fail.\n");
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
                                                  0x8000,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, false);
        KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Upscaling exactly 2x should work\n");
        KUNIT_EXPECT_TRUE(test, plane_state.visible);
 
        set_src(&plane_state, 0, 0, 2048 << 16, 1536 << 16);
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  0x1ffff, false, false);
        KUNIT_EXPECT_TRUE_MSG(test, ret, "Downscaling out of range should fail.\n");
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  0x20000, false, false);
        KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Should succeed with exact scaling limit\n");
        KUNIT_EXPECT_TRUE(test, plane_state.visible);
        set_src(&plane_state, 0, 0, 0x40001, 0x40001);
        set_crtc(&plane_state, 1022, 766, 4, 4);
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  0x10001,
                                                  true, false);
        KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Should succeed by clipping to exact multiple");
        set_src(&plane_state, 0x20001, 0x20001, 0x4040001, 0x3040001);
        set_crtc(&plane_state, -2, -2, 1028, 772);
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  0x10001,
                                                  false, false);
        KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Should succeed by clipping to exact multiple");
        set_crtc(&plane_state, 1022, 766, 4, 4);
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
                                                  0xffff,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  true, false);
        KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Should succeed by clipping to exact multiple");
        KUNIT_EXPECT_TRUE(test, plane_state.visible);
        set_crtc(&plane_state, -2, -2, 1028, 772);
        ret = drm_atomic_helper_check_plane_state(&plane_state, &crtc_state,
                                                  0xffff,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, false);
        KUNIT_EXPECT_FALSE_MSG(test, ret, 0, "Should succeed by clipping to exact multiple");
        KUNIT_EXPECT_TRUE(test, plane_state.visible);
 
        }
 
        return drm_atomic_helper_check_plane_state(new_state, crtc_state,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
                                                   false, true);
 }
 
        }
 
        ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  true, true);
        if (ret)
                return ret;
 
                 return PTR_ERR(crtc_state);
 
        ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  is_cursor, true);
        return ret;
 }
 
                can_position = true;
 
        ret = drm_atomic_helper_check_plane_state(new_plane_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  can_position, true);
        if (ret != 0)
                return ret;
 
                                                           new_state->crtc);
 
        ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  false, true);
 
        if (!ret && new_fb) {
                                                           new_state->crtc);
 
        ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
-                                                 DRM_PLANE_HELPER_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
+                                                 DRM_PLANE_NO_SCALING,
                                                  true, true);
        if (ret)
                return ret;
 
 
        return drm_atomic_helper_check_plane_state(new_plane_state,
                                                   crtc_state,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
-                                                  DRM_PLANE_HELPER_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
+                                                  DRM_PLANE_NO_SCALING,
                                                   false, false);
 }
 
 
  * Due to src being in 16.16 fixed point and dest being in integer pixels,
  * 1<<16 represents no scaling.
  */
-#define DRM_PLANE_HELPER_NO_SCALING (1<<16)
+#define DRM_PLANE_NO_SCALING (1<<16)
 
 struct drm_atomic_state;
 struct drm_private_obj;