// SPDX-License-Identifier: MIT
/*
 * Copyright © 2021 Intel Corporation
 */

#include <drm/drm_framebuffer.h>

#include "intel_display.h"
#include "intel_display_types.h"
#include "intel_fb.h"

#define check_array_bounds(i915, a, i) drm_WARN_ON(&(i915)->drm, (i) >= ARRAY_SIZE(a))

bool is_ccs_plane(const struct drm_framebuffer *fb, int plane)
{
        if (!is_ccs_modifier(fb->modifier))
                return false;

        return plane >= fb->format->num_planes / 2;
}

bool is_gen12_ccs_plane(const struct drm_framebuffer *fb, int plane)
{
        return is_gen12_ccs_modifier(fb->modifier) && is_ccs_plane(fb, plane);
}

bool is_gen12_ccs_cc_plane(const struct drm_framebuffer *fb, int plane)
{
        return fb->modifier == I915_FORMAT_MOD_Y_TILED_GEN12_RC_CCS_CC &&
               plane == 2;
}

bool is_semiplanar_uv_plane(const struct drm_framebuffer *fb, int color_plane)
{
        return intel_format_info_is_yuv_semiplanar(fb->format, fb->modifier) &&
                color_plane == 1;
}

bool is_surface_linear(const struct drm_framebuffer *fb, int color_plane)
{
        return fb->modifier == DRM_FORMAT_MOD_LINEAR ||
               is_gen12_ccs_plane(fb, color_plane);
}

int main_to_ccs_plane(const struct drm_framebuffer *fb, int main_plane)
{
        drm_WARN_ON(fb->dev, !is_ccs_modifier(fb->modifier) ||
                    (main_plane && main_plane >= fb->format->num_planes / 2));

        return fb->format->num_planes / 2 + main_plane;
}

int skl_ccs_to_main_plane(const struct drm_framebuffer *fb, int ccs_plane)
{
        drm_WARN_ON(fb->dev, !is_ccs_modifier(fb->modifier) ||
                    ccs_plane < fb->format->num_planes / 2);

        if (is_gen12_ccs_cc_plane(fb, ccs_plane))
                return 0;

        return ccs_plane - fb->format->num_planes / 2;
}

int skl_main_to_aux_plane(const struct drm_framebuffer *fb, int main_plane)
{
        struct drm_i915_private *i915 = to_i915(fb->dev);

        if (is_ccs_modifier(fb->modifier))
                return main_to_ccs_plane(fb, main_plane);
        else if (DISPLAY_VER(i915) < 11 &&
                 intel_format_info_is_yuv_semiplanar(fb->format, fb->modifier))
                return 1;
        else
                return 0;
}

unsigned int intel_tile_size(const struct drm_i915_private *i915)
{
        return DISPLAY_VER(i915) == 2 ? 2048 : 4096;
}

unsigned int intel_tile_height(const struct drm_framebuffer *fb, int color_plane)
{
        if (is_gen12_ccs_plane(fb, color_plane))
                return 1;

        return intel_tile_size(to_i915(fb->dev)) /
                intel_tile_width_bytes(fb, color_plane);
}

/* Return the tile dimensions in pixel units */
static void intel_tile_dims(const struct drm_framebuffer *fb, int color_plane,
                            unsigned int *tile_width,
                            unsigned int *tile_height)
{
        unsigned int tile_width_bytes = intel_tile_width_bytes(fb, color_plane);
        unsigned int cpp = fb->format->cpp[color_plane];

        *tile_width = tile_width_bytes / cpp;
        *tile_height = intel_tile_height(fb, color_plane);
}

unsigned int intel_tile_row_size(const struct drm_framebuffer *fb, int color_plane)
{
        unsigned int tile_width, tile_height;

        intel_tile_dims(fb, color_plane, &tile_width, &tile_height);

        return fb->pitches[color_plane] * tile_height;
}

unsigned int intel_cursor_alignment(const struct drm_i915_private *i915)
{
        if (IS_I830(i915))
                return 16 * 1024;
        else if (IS_I85X(i915))
                return 256;
        else if (IS_I845G(i915) || IS_I865G(i915))
                return 32;
        else
                return 4 * 1024;
}

void intel_fb_plane_get_subsampling(int *hsub, int *vsub,
                                    const struct drm_framebuffer *fb,
                                    int color_plane)
{
        int main_plane;

        if (color_plane == 0) {
                *hsub = 1;
                *vsub = 1;

                return;
        }

        /*
         * TODO: Deduct the subsampling from the char block for all CCS
         * formats and planes.
         */
        if (!is_gen12_ccs_plane(fb, color_plane)) {
                *hsub = fb->format->hsub;
                *vsub = fb->format->vsub;

                return;
        }

        main_plane = skl_ccs_to_main_plane(fb, color_plane);
        *hsub = drm_format_info_block_width(fb->format, color_plane) /
                drm_format_info_block_width(fb->format, main_plane);

        /*
         * The min stride check in the core framebuffer_check() function
         * assumes that format->hsub applies to every plane except for the
         * first plane. That's incorrect for the CCS AUX plane of the first
         * plane, but for the above check to pass we must define the block
         * width with that subsampling applied to it. Adjust the width here
         * accordingly, so we can calculate the actual subsampling factor.
         */
        if (main_plane == 0)
                *hsub *= fb->format->hsub;

        *vsub = 32;
}

static void intel_fb_plane_dims(const struct intel_framebuffer *fb, int color_plane, int *w, int *h)
{
        int main_plane = is_ccs_plane(&fb->base, color_plane) ?
                         skl_ccs_to_main_plane(&fb->base, color_plane) : 0;
        int main_hsub, main_vsub;
        int hsub, vsub;

        intel_fb_plane_get_subsampling(&main_hsub, &main_vsub, &fb->base, main_plane);
        intel_fb_plane_get_subsampling(&hsub, &vsub, &fb->base, color_plane);
        *w = fb->base.width / main_hsub / hsub;
        *h = fb->base.height / main_vsub / vsub;
}

static u32 intel_adjust_tile_offset(int *x, int *y,
                                    unsigned int tile_width,
                                    unsigned int tile_height,
                                    unsigned int tile_size,
                                    unsigned int pitch_tiles,
                                    u32 old_offset,
                                    u32 new_offset)
{
        unsigned int pitch_pixels = pitch_tiles * tile_width;
        unsigned int tiles;

        WARN_ON(old_offset & (tile_size - 1));
        WARN_ON(new_offset & (tile_size - 1));
        WARN_ON(new_offset > old_offset);

        tiles = (old_offset - new_offset) / tile_size;

        *y += tiles / pitch_tiles * tile_height;
        *x += tiles % pitch_tiles * tile_width;

        /* minimize x in case it got needlessly big */
        *y += *x / pitch_pixels * tile_height;
        *x %= pitch_pixels;

        return new_offset;
}

static u32 intel_adjust_aligned_offset(int *x, int *y,
                                       const struct drm_framebuffer *fb,
                                       int color_plane,
                                       unsigned int rotation,
                                       unsigned int pitch,
                                       u32 old_offset, u32 new_offset)
{
        struct drm_i915_private *i915 = to_i915(fb->dev);
        unsigned int cpp = fb->format->cpp[color_plane];

        drm_WARN_ON(&i915->drm, new_offset > old_offset);

        if (!is_surface_linear(fb, color_plane)) {
                unsigned int tile_size, tile_width, tile_height;
                unsigned int pitch_tiles;

                tile_size = intel_tile_size(i915);
                intel_tile_dims(fb, color_plane, &tile_width, &tile_height);

                if (drm_rotation_90_or_270(rotation)) {
                        pitch_tiles = pitch / tile_height;
                        swap(tile_width, tile_height);
                } else {
                        pitch_tiles = pitch / (tile_width * cpp);
                }

                intel_adjust_tile_offset(x, y, tile_width, tile_height,
                                         tile_size, pitch_tiles,
                                         old_offset, new_offset);
        } else {
                old_offset += *y * pitch + *x * cpp;

                *y = (old_offset - new_offset) / pitch;
                *x = ((old_offset - new_offset) - *y * pitch) / cpp;
        }

        return new_offset;
}

/*
 * Adjust the tile offset by moving the difference into
 * the x/y offsets.
 */
u32 intel_plane_adjust_aligned_offset(int *x, int *y,
                                      const struct intel_plane_state *state,
                                      int color_plane,
                                      u32 old_offset, u32 new_offset)
{
        return intel_adjust_aligned_offset(x, y, state->hw.fb, color_plane,
                                           state->hw.rotation,
                                           state->view.color_plane[color_plane].stride,
                                           old_offset, new_offset);
}

/*
 * Computes the aligned offset to the base tile and adjusts
 * x, y. bytes per pixel is assumed to be a power-of-two.
 *
 * In the 90/270 rotated case, x and y are assumed
 * to be already rotated to match the rotated GTT view, and
 * pitch is the tile_height aligned framebuffer height.
 *
 * This function is used when computing the derived information
 * under intel_framebuffer, so using any of that information
 * here is not allowed. Anything under drm_framebuffer can be
 * used. This is why the user has to pass in the pitch since it
 * is specified in the rotated orientation.
 */
static u32 intel_compute_aligned_offset(struct drm_i915_private *i915,
                                        int *x, int *y,
                                        const struct drm_framebuffer *fb,
                                        int color_plane,
                                        unsigned int pitch,
                                        unsigned int rotation,
                                        u32 alignment)
{
        unsigned int cpp = fb->format->cpp[color_plane];
        u32 offset, offset_aligned;

        if (!is_surface_linear(fb, color_plane)) {
                unsigned int tile_size, tile_width, tile_height;
                unsigned int tile_rows, tiles, pitch_tiles;

                tile_size = intel_tile_size(i915);
                intel_tile_dims(fb, color_plane, &tile_width, &tile_height);

                if (drm_rotation_90_or_270(rotation)) {
                        pitch_tiles = pitch / tile_height;
                        swap(tile_width, tile_height);
                } else {
                        pitch_tiles = pitch / (tile_width * cpp);
                }

                tile_rows = *y / tile_height;
                *y %= tile_height;

                tiles = *x / tile_width;
                *x %= tile_width;

                offset = (tile_rows * pitch_tiles + tiles) * tile_size;

                offset_aligned = offset;
                if (alignment)
                        offset_aligned = rounddown(offset_aligned, alignment);

                intel_adjust_tile_offset(x, y, tile_width, tile_height,
                                         tile_size, pitch_tiles,
                                         offset, offset_aligned);
        } else {
                offset = *y * pitch + *x * cpp;
                offset_aligned = offset;
                if (alignment) {
                        offset_aligned = rounddown(offset_aligned, alignment);
                        *y = (offset % alignment) / pitch;
                        *x = ((offset % alignment) - *y * pitch) / cpp;
                } else {
                        *y = *x = 0;
                }
        }

        return offset_aligned;
}

u32 intel_plane_compute_aligned_offset(int *x, int *y,
                                       const struct intel_plane_state *state,
                                       int color_plane)
{
        struct intel_plane *intel_plane = to_intel_plane(state->uapi.plane);
        struct drm_i915_private *i915 = to_i915(intel_plane->base.dev);
        const struct drm_framebuffer *fb = state->hw.fb;
        unsigned int rotation = state->hw.rotation;
        int pitch = state->view.color_plane[color_plane].stride;
        u32 alignment;

        if (intel_plane->id == PLANE_CURSOR)
                alignment = intel_cursor_alignment(i915);
        else
                alignment = intel_surf_alignment(fb, color_plane);

        return intel_compute_aligned_offset(i915, x, y, fb, color_plane,
                                            pitch, rotation, alignment);
}

/* Convert the fb->offset[] into x/y offsets */
static int intel_fb_offset_to_xy(int *x, int *y,
                                 const struct drm_framebuffer *fb,
                                 int color_plane)
{
        struct drm_i915_private *i915 = to_i915(fb->dev);
        unsigned int height;
        u32 alignment;

        /*
         * All DPT color planes must be 512*4k aligned (the amount mapped by a
         * single DPT page). For ADL_P CCS FBs this only works by requiring
         * the allocated offsets to be 2MB aligned.  Once supoort to remap
         * such FBs is added we can remove this requirement, as then all the
         * planes can be remapped to an aligned offset.
         */
        if (IS_ALDERLAKE_P(i915) && is_ccs_modifier(fb->modifier))
                alignment = 512 * 4096;
        else if (DISPLAY_VER(i915) >= 12 &&
                 is_semiplanar_uv_plane(fb, color_plane))
                alignment = intel_tile_row_size(fb, color_plane);
        else if (fb->modifier != DRM_FORMAT_MOD_LINEAR)
                alignment = intel_tile_size(i915);
        else
                alignment = 0;

        if (alignment != 0 && fb->offsets[color_plane] % alignment) {
                drm_dbg_kms(&i915->drm,
                            "Misaligned offset 0x%08x for color plane %d\n",
                            fb->offsets[color_plane], color_plane);
                return -EINVAL;
        }

        height = drm_framebuffer_plane_height(fb->height, fb, color_plane);
        height = ALIGN(height, intel_tile_height(fb, color_plane));

        /* Catch potential overflows early */
        if (add_overflows_t(u32, mul_u32_u32(height, fb->pitches[color_plane]),
                            fb->offsets[color_plane])) {
                drm_dbg_kms(&i915->drm,
                            "Bad offset 0x%08x or pitch %d for color plane %d\n",
                            fb->offsets[color_plane], fb->pitches[color_plane],
                            color_plane);
                return -ERANGE;
        }

        *x = 0;
        *y = 0;

        intel_adjust_aligned_offset(x, y,
                                    fb, color_plane, DRM_MODE_ROTATE_0,
                                    fb->pitches[color_plane],
                                    fb->offsets[color_plane], 0);

        return 0;
}

static int intel_fb_check_ccs_xy(const struct drm_framebuffer *fb, int ccs_plane, int x, int y)
{
        struct drm_i915_private *i915 = to_i915(fb->dev);
        const struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
        int main_plane;
        int hsub, vsub;
        int tile_width, tile_height;
        int ccs_x, ccs_y;
        int main_x, main_y;

        if (!is_ccs_plane(fb, ccs_plane) || is_gen12_ccs_cc_plane(fb, ccs_plane))
                return 0;

        intel_tile_dims(fb, ccs_plane, &tile_width, &tile_height);
        intel_fb_plane_get_subsampling(&hsub, &vsub, fb, ccs_plane);

        tile_width *= hsub;
        tile_height *= vsub;

        ccs_x = (x * hsub) % tile_width;
        ccs_y = (y * vsub) % tile_height;

        main_plane = skl_ccs_to_main_plane(fb, ccs_plane);
        main_x = intel_fb->normal_view.color_plane[main_plane].x % tile_width;
        main_y = intel_fb->normal_view.color_plane[main_plane].y % tile_height;

        /*
         * CCS doesn't have its own x/y offset register, so the intra CCS tile
         * x/y offsets must match between CCS and the main surface.
         */
        if (main_x != ccs_x || main_y != ccs_y) {
                drm_dbg_kms(&i915->drm,
                              "Bad CCS x/y (main %d,%d ccs %d,%d) full (main %d,%d ccs %d,%d)\n",
                              main_x, main_y,
                              ccs_x, ccs_y,
                              intel_fb->normal_view.color_plane[main_plane].x,
                              intel_fb->normal_view.color_plane[main_plane].y,
                              x, y);
                return -EINVAL;
        }

        return 0;
}

static bool intel_plane_can_remap(const struct intel_plane_state *plane_state)
{
        struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        struct drm_i915_private *i915 = to_i915(plane->base.dev);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        int i;

        /* We don't want to deal with remapping with cursors */
        if (plane->id == PLANE_CURSOR)
                return false;

        /*
         * The display engine limits already match/exceed the
         * render engine limits, so not much point in remapping.
         * Would also need to deal with the fence POT alignment
         * and gen2 2KiB GTT tile size.
         */
        if (DISPLAY_VER(i915) < 4)
                return false;

        /*
         * The new CCS hash mode isn't compatible with remapping as
         * the virtual address of the pages affects the compressed data.
         */
        if (is_ccs_modifier(fb->modifier))
                return false;

        /* Linear needs a page aligned stride for remapping */
        if (fb->modifier == DRM_FORMAT_MOD_LINEAR) {
                unsigned int alignment = intel_tile_size(i915) - 1;

                for (i = 0; i < fb->format->num_planes; i++) {
                        if (fb->pitches[i] & alignment)
                                return false;
                }
        }

        return true;
}

bool intel_fb_needs_pot_stride_remap(const struct intel_framebuffer *fb)
{
        struct drm_i915_private *i915 = to_i915(fb->base.dev);

        return IS_ALDERLAKE_P(i915) && fb->base.modifier != DRM_FORMAT_MOD_LINEAR &&
               !is_ccs_modifier(fb->base.modifier);
}

static int intel_fb_pitch(const struct intel_framebuffer *fb, int color_plane, unsigned int rotation)
{
        if (drm_rotation_90_or_270(rotation))
                return fb->rotated_view.color_plane[color_plane].stride;
        else if (intel_fb_needs_pot_stride_remap(fb))
                return fb->remapped_view.color_plane[color_plane].stride;
        else
                return fb->normal_view.color_plane[color_plane].stride;
}

static bool intel_plane_needs_remap(const struct intel_plane_state *plane_state)
{
        struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        const struct intel_framebuffer *fb = to_intel_framebuffer(plane_state->hw.fb);
        unsigned int rotation = plane_state->hw.rotation;
        u32 stride, max_stride;

        /*
         * No remapping for invisible planes since we don't have
         * an actual source viewport to remap.
         */
        if (!plane_state->uapi.visible)
                return false;

        if (!intel_plane_can_remap(plane_state))
                return false;

        /*
         * FIXME: aux plane limits on gen9+ are
         * unclear in Bspec, for now no checking.
         */
        stride = intel_fb_pitch(fb, 0, rotation);
        max_stride = plane->max_stride(plane, fb->base.format->format,
                                       fb->base.modifier, rotation);

        return stride > max_stride;
}

static int convert_plane_offset_to_xy(const struct intel_framebuffer *fb, int color_plane,
                                      int plane_width, int *x, int *y)
{
        struct drm_i915_gem_object *obj = intel_fb_obj(&fb->base);
        int ret;

        ret = intel_fb_offset_to_xy(x, y, &fb->base, color_plane);
        if (ret) {
                drm_dbg_kms(fb->base.dev,
                            "bad fb plane %d offset: 0x%x\n",
                            color_plane, fb->base.offsets[color_plane]);
                return ret;
        }

        ret = intel_fb_check_ccs_xy(&fb->base, color_plane, *x, *y);
        if (ret)
                return ret;

        /*
         * The fence (if used) is aligned to the start of the object
         * so having the framebuffer wrap around across the edge of the
         * fenced region doesn't really work. We have no API to configure
         * the fence start offset within the object (nor could we probably
         * on gen2/3). So it's just easier if we just require that the
         * fb layout agrees with the fence layout. We already check that the
         * fb stride matches the fence stride elsewhere.
         */
        if (color_plane == 0 && i915_gem_object_is_tiled(obj) &&
            (*x + plane_width) * fb->base.format->cpp[color_plane] > fb->base.pitches[color_plane]) {
                drm_dbg_kms(fb->base.dev,
                            "bad fb plane %d offset: 0x%x\n",
                            color_plane, fb->base.offsets[color_plane]);
                return -EINVAL;
        }

        return 0;
}

static u32 calc_plane_aligned_offset(const struct intel_framebuffer *fb, int color_plane, int *x, int *y)
{
        struct drm_i915_private *i915 = to_i915(fb->base.dev);
        unsigned int tile_size = intel_tile_size(i915);
        u32 offset;

        offset = intel_compute_aligned_offset(i915, x, y, &fb->base, color_plane,
                                              fb->base.pitches[color_plane],
                                              DRM_MODE_ROTATE_0,
                                              tile_size);

        return offset / tile_size;
}

struct fb_plane_view_dims {
        unsigned int width, height;
        unsigned int tile_width, tile_height;
};

static void init_plane_view_dims(const struct intel_framebuffer *fb, int color_plane,
                                 unsigned int width, unsigned int height,
                                 struct fb_plane_view_dims *dims)
{
        dims->width = width;
        dims->height = height;

        intel_tile_dims(&fb->base, color_plane, &dims->tile_width, &dims->tile_height);
}

static unsigned int
plane_view_src_stride_tiles(const struct intel_framebuffer *fb, int color_plane,
                            const struct fb_plane_view_dims *dims)
{
        return DIV_ROUND_UP(fb->base.pitches[color_plane],
                            dims->tile_width * fb->base.format->cpp[color_plane]);
}

static unsigned int
plane_view_dst_stride_tiles(const struct intel_framebuffer *fb, int color_plane,
                            unsigned int pitch_tiles)
{
        if (intel_fb_needs_pot_stride_remap(fb))
                /*
                 * ADL_P, the only platform needing a POT stride has a minimum
                 * of 8 stride tiles.
                 */
                return roundup_pow_of_two(max(pitch_tiles, 8u));
        else
                return pitch_tiles;
}

static unsigned int
plane_view_width_tiles(const struct intel_framebuffer *fb, int color_plane,
                       const struct fb_plane_view_dims *dims,
                       int x)
{
        return DIV_ROUND_UP(x + dims->width, dims->tile_width);
}

static unsigned int
plane_view_height_tiles(const struct intel_framebuffer *fb, int color_plane,
                        const struct fb_plane_view_dims *dims,
                        int y)
{
        return DIV_ROUND_UP(y + dims->height, dims->tile_height);
}

#define assign_chk_ovf(i915, var, val) ({ \
        drm_WARN_ON(&(i915)->drm, overflows_type(val, var)); \
        (var) = (val); \
})

static u32 calc_plane_remap_info(const struct intel_framebuffer *fb, int color_plane,
                                 const struct fb_plane_view_dims *dims,
                                 u32 obj_offset, u32 gtt_offset, int x, int y,
                                 struct intel_fb_view *view)
{
        struct drm_i915_private *i915 = to_i915(fb->base.dev);
        struct intel_remapped_plane_info *remap_info = &view->gtt.remapped.plane[color_plane];
        struct i915_color_plane_view *color_plane_info = &view->color_plane[color_plane];
        unsigned int tile_width = dims->tile_width;
        unsigned int tile_height = dims->tile_height;
        unsigned int tile_size = intel_tile_size(i915);
        struct drm_rect r;
        u32 size;

        assign_chk_ovf(i915, remap_info->offset, obj_offset);
        assign_chk_ovf(i915, remap_info->src_stride, plane_view_src_stride_tiles(fb, color_plane, dims));
        assign_chk_ovf(i915, remap_info->width, plane_view_width_tiles(fb, color_plane, dims, x));
        assign_chk_ovf(i915, remap_info->height, plane_view_height_tiles(fb, color_plane, dims, y));

        if (view->gtt.type == I915_GGTT_VIEW_ROTATED) {
                check_array_bounds(i915, view->gtt.rotated.plane, color_plane);

                assign_chk_ovf(i915, remap_info->dst_stride,
                               plane_view_dst_stride_tiles(fb, color_plane, remap_info->height));

                /* rotate the x/y offsets to match the GTT view */
                drm_rect_init(&r, x, y, dims->width, dims->height);
                drm_rect_rotate(&r,
                                remap_info->width * tile_width,
                                remap_info->height * tile_height,
                                DRM_MODE_ROTATE_270);

                color_plane_info->x = r.x1;
                color_plane_info->y = r.y1;

                color_plane_info->stride = remap_info->dst_stride * tile_height;

                size = remap_info->dst_stride * remap_info->width;

                /* rotate the tile dimensions to match the GTT view */
                swap(tile_width, tile_height);
        } else {
                drm_WARN_ON(&i915->drm, view->gtt.type != I915_GGTT_VIEW_REMAPPED);

                check_array_bounds(i915, view->gtt.remapped.plane, color_plane);

                assign_chk_ovf(i915, remap_info->dst_stride,
                               plane_view_dst_stride_tiles(fb, color_plane, remap_info->width));

                color_plane_info->x = x;
                color_plane_info->y = y;

                color_plane_info->stride = remap_info->dst_stride * tile_width *
                                           fb->base.format->cpp[color_plane];

                size = remap_info->dst_stride * remap_info->height;
        }

        /*
         * We only keep the x/y offsets, so push all of the gtt offset into
         * the x/y offsets.  x,y will hold the first pixel of the framebuffer
         * plane from the start of the remapped/rotated gtt mapping.
         */
        intel_adjust_tile_offset(&color_plane_info->x, &color_plane_info->y,
                                 tile_width, tile_height,
                                 tile_size, remap_info->dst_stride,
                                 gtt_offset * tile_size, 0);

        return size;
}

#undef assign_chk_ovf

/* Return number of tiles @color_plane needs. */
static unsigned int
calc_plane_normal_size(const struct intel_framebuffer *fb, int color_plane,
                       const struct fb_plane_view_dims *dims,
                       int x, int y)
{
        struct drm_i915_private *i915 = to_i915(fb->base.dev);
        unsigned int tiles;

        if (is_surface_linear(&fb->base, color_plane)) {
                unsigned int size;

                size = (y + dims->height) * fb->base.pitches[color_plane] +
                       x * fb->base.format->cpp[color_plane];
                tiles = DIV_ROUND_UP(size, intel_tile_size(i915));
        } else {
                tiles = plane_view_src_stride_tiles(fb, color_plane, dims) *
                        plane_view_height_tiles(fb, color_plane, dims, y);
                /*
                 * If the plane isn't horizontally tile aligned,
                 * we need one more tile.
                 */
                if (x != 0)
                        tiles++;
        }

        return tiles;
}

static void intel_fb_view_init(struct intel_fb_view *view, enum i915_ggtt_view_type view_type)
{
        memset(view, 0, sizeof(*view));
        view->gtt.type = view_type;
}

bool intel_fb_supports_90_270_rotation(const struct intel_framebuffer *fb)
{
        if (DISPLAY_VER(to_i915(fb->base.dev)) >= 13)
                return false;

        return fb->base.modifier == I915_FORMAT_MOD_Y_TILED ||
               fb->base.modifier == I915_FORMAT_MOD_Yf_TILED;
}

int intel_fill_fb_info(struct drm_i915_private *i915, struct intel_framebuffer *fb)
{
        struct drm_i915_gem_object *obj = intel_fb_obj(&fb->base);
        u32 gtt_offset_rotated = 0;
        u32 gtt_offset_remapped = 0;
        unsigned int max_size = 0;
        int i, num_planes = fb->base.format->num_planes;
        unsigned int tile_size = intel_tile_size(i915);

        intel_fb_view_init(&fb->normal_view, I915_GGTT_VIEW_NORMAL);

        drm_WARN_ON(&i915->drm,
                    intel_fb_supports_90_270_rotation(fb) &&
                    intel_fb_needs_pot_stride_remap(fb));

        if (intel_fb_supports_90_270_rotation(fb))
                intel_fb_view_init(&fb->rotated_view, I915_GGTT_VIEW_ROTATED);
        if (intel_fb_needs_pot_stride_remap(fb))
                intel_fb_view_init(&fb->remapped_view, I915_GGTT_VIEW_REMAPPED);

        for (i = 0; i < num_planes; i++) {
                struct fb_plane_view_dims view_dims;
                unsigned int width, height;
                unsigned int cpp, size;
                u32 offset;
                int x, y;
                int ret;

                /*
                 * Plane 2 of Render Compression with Clear Color fb modifier
                 * is consumed by the driver and not passed to DE. Skip the
                 * arithmetic related to alignment and offset calculation.
                 */
                if (is_gen12_ccs_cc_plane(&fb->base, i)) {
                        if (IS_ALIGNED(fb->base.offsets[i], PAGE_SIZE))
                                continue;
                        else
                                return -EINVAL;
                }

                cpp = fb->base.format->cpp[i];
                intel_fb_plane_dims(fb, i, &width, &height);

                ret = convert_plane_offset_to_xy(fb, i, width, &x, &y);
                if (ret)
                        return ret;

                init_plane_view_dims(fb, i, width, height, &view_dims);

                /*
                 * First pixel of the framebuffer from
                 * the start of the normal gtt mapping.
                 */
                fb->normal_view.color_plane[i].x = x;
                fb->normal_view.color_plane[i].y = y;
                fb->normal_view.color_plane[i].stride = fb->base.pitches[i];

                offset = calc_plane_aligned_offset(fb, i, &x, &y);

                if (intel_fb_supports_90_270_rotation(fb))
                        gtt_offset_rotated += calc_plane_remap_info(fb, i, &view_dims,
                                                                    offset, gtt_offset_rotated, x, y,
                                                                    &fb->rotated_view);

                if (intel_fb_needs_pot_stride_remap(fb))
                        gtt_offset_remapped += calc_plane_remap_info(fb, i, &view_dims,
                                                                     offset, gtt_offset_remapped, x, y,
                                                                     &fb->remapped_view);

                size = calc_plane_normal_size(fb, i, &view_dims, x, y);
                /* how many tiles in total needed in the bo */
                max_size = max(max_size, offset + size);
        }

        if (mul_u32_u32(max_size, tile_size) > obj->base.size) {
                drm_dbg_kms(&i915->drm,
                            "fb too big for bo (need %llu bytes, have %zu bytes)\n",
                            mul_u32_u32(max_size, tile_size), obj->base.size);
                return -EINVAL;
        }

        return 0;
}

static void intel_plane_remap_gtt(struct intel_plane_state *plane_state)
{
        struct drm_i915_private *i915 =
                to_i915(plane_state->uapi.plane->dev);
        struct drm_framebuffer *fb = plane_state->hw.fb;
        struct intel_framebuffer *intel_fb = to_intel_framebuffer(fb);
        unsigned int rotation = plane_state->hw.rotation;
        int i, num_planes = fb->format->num_planes;
        unsigned int src_x, src_y;
        unsigned int src_w, src_h;
        u32 gtt_offset = 0;

        intel_fb_view_init(&plane_state->view,
                           drm_rotation_90_or_270(rotation) ? I915_GGTT_VIEW_ROTATED :
                                                              I915_GGTT_VIEW_REMAPPED);

        src_x = plane_state->uapi.src.x1 >> 16;
        src_y = plane_state->uapi.src.y1 >> 16;
        src_w = drm_rect_width(&plane_state->uapi.src) >> 16;
        src_h = drm_rect_height(&plane_state->uapi.src) >> 16;

        drm_WARN_ON(&i915->drm, is_ccs_modifier(fb->modifier));

        /* Make src coordinates relative to the viewport */
        drm_rect_translate(&plane_state->uapi.src,
                           -(src_x << 16), -(src_y << 16));

        /* Rotate src coordinates to match rotated GTT view */
        if (drm_rotation_90_or_270(rotation))
                drm_rect_rotate(&plane_state->uapi.src,
                                src_w << 16, src_h << 16,
                                DRM_MODE_ROTATE_270);

        for (i = 0; i < num_planes; i++) {
                unsigned int hsub = i ? fb->format->hsub : 1;
                unsigned int vsub = i ? fb->format->vsub : 1;
                struct fb_plane_view_dims view_dims;
                unsigned int width, height;
                unsigned int x, y;
                u32 offset;

                x = src_x / hsub;
                y = src_y / vsub;
                width = src_w / hsub;
                height = src_h / vsub;

                init_plane_view_dims(intel_fb, i, width, height, &view_dims);

                /*
                 * First pixel of the src viewport from the
                 * start of the normal gtt mapping.
                 */
                x += intel_fb->normal_view.color_plane[i].x;
                y += intel_fb->normal_view.color_plane[i].y;

                offset = calc_plane_aligned_offset(intel_fb, i, &x, &y);

                gtt_offset += calc_plane_remap_info(intel_fb, i, &view_dims,
                                                    offset, gtt_offset, x, y,
                                                    &plane_state->view);
        }
}

void intel_fb_fill_view(const struct intel_framebuffer *fb, unsigned int rotation,
                        struct intel_fb_view *view)
{
        if (drm_rotation_90_or_270(rotation))
                *view = fb->rotated_view;
        else if (intel_fb_needs_pot_stride_remap(fb))
                *view = fb->remapped_view;
        else
                *view = fb->normal_view;
}

static int intel_plane_check_stride(const struct intel_plane_state *plane_state)
{
        struct intel_plane *plane = to_intel_plane(plane_state->uapi.plane);
        const struct drm_framebuffer *fb = plane_state->hw.fb;
        unsigned int rotation = plane_state->hw.rotation;
        u32 stride, max_stride;

        /*
         * We ignore stride for all invisible planes that
         * can be remapped. Otherwise we could end up
         * with a false positive when the remapping didn't
         * kick in due the plane being invisible.
         */
        if (intel_plane_can_remap(plane_state) &&
            !plane_state->uapi.visible)
                return 0;

        /* FIXME other color planes? */
        stride = plane_state->view.color_plane[0].stride;
        max_stride = plane->max_stride(plane, fb->format->format,
                                       fb->modifier, rotation);

        if (stride > max_stride) {
                DRM_DEBUG_KMS("[FB:%d] stride (%d) exceeds [PLANE:%d:%s] max stride (%d)\n",
                              fb->base.id, stride,
                              plane->base.base.id, plane->base.name, max_stride);
                return -EINVAL;
        }

        return 0;
}

int intel_plane_compute_gtt(struct intel_plane_state *plane_state)
{
        const struct intel_framebuffer *fb =
                to_intel_framebuffer(plane_state->hw.fb);
        unsigned int rotation = plane_state->hw.rotation;

        if (!fb)
                return 0;

        if (intel_plane_needs_remap(plane_state)) {
                intel_plane_remap_gtt(plane_state);

                /*
                 * Sometimes even remapping can't overcome
                 * the stride limitations :( Can happen with
                 * big plane sizes and suitably misaligned
                 * offsets.
                 */
                return intel_plane_check_stride(plane_state);
        }

        intel_fb_fill_view(fb, rotation, &plane_state->view);

        /* Rotate src coordinates to match rotated GTT view */
        if (drm_rotation_90_or_270(rotation))
                drm_rect_rotate(&plane_state->uapi.src,
                                fb->base.width << 16, fb->base.height << 16,
                                DRM_MODE_ROTATE_270);

        return intel_plane_check_stride(plane_state);
}