674 lines
19 KiB
C
674 lines
19 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright 2019 NXP.
|
|
*/
|
|
|
|
#include <drm/drm_atomic.h>
|
|
#include <drm/drm_atomic_helper.h>
|
|
#include <linux/dma-buf.h>
|
|
#include <drm/drm_drv.h>
|
|
#include <drm/drm_fb_cma_helper.h>
|
|
#include <drm/drm_gem_framebuffer_helper.h>
|
|
#include <drm/drm_gem_cma_helper.h>
|
|
|
|
#include "dcss-dev.h"
|
|
#include "dcss-kms.h"
|
|
|
|
static const u32 dcss_graphics_formats[] = {
|
|
/* RGB */
|
|
DRM_FORMAT_ARGB8888,
|
|
DRM_FORMAT_XRGB8888,
|
|
DRM_FORMAT_ABGR8888,
|
|
DRM_FORMAT_XBGR8888,
|
|
DRM_FORMAT_RGBA8888,
|
|
DRM_FORMAT_RGBX8888,
|
|
DRM_FORMAT_BGRA8888,
|
|
DRM_FORMAT_BGRX8888,
|
|
DRM_FORMAT_XRGB2101010,
|
|
DRM_FORMAT_XBGR2101010,
|
|
DRM_FORMAT_RGBX1010102,
|
|
DRM_FORMAT_BGRX1010102,
|
|
DRM_FORMAT_ARGB2101010,
|
|
DRM_FORMAT_ABGR2101010,
|
|
DRM_FORMAT_RGBA1010102,
|
|
DRM_FORMAT_BGRA1010102,
|
|
};
|
|
|
|
static const u32 dcss_video_formats[] = {
|
|
/* YUV444 */
|
|
DRM_FORMAT_AYUV,
|
|
|
|
/* YUV422 */
|
|
DRM_FORMAT_UYVY,
|
|
DRM_FORMAT_VYUY,
|
|
DRM_FORMAT_YUYV,
|
|
DRM_FORMAT_YVYU,
|
|
|
|
/* YUV420 */
|
|
DRM_FORMAT_NV12,
|
|
DRM_FORMAT_NV21,
|
|
DRM_FORMAT_NV12_10LE40,
|
|
};
|
|
|
|
static const u64 dcss_video_format_modifiers[] = {
|
|
DRM_FORMAT_MOD_VSI_G1_TILED,
|
|
DRM_FORMAT_MOD_VSI_G2_TILED,
|
|
DRM_FORMAT_MOD_VSI_G2_TILED_COMPRESSED,
|
|
DRM_FORMAT_MOD_LINEAR,
|
|
DRM_FORMAT_MOD_INVALID,
|
|
};
|
|
|
|
static const u64 dcss_graphics_format_modifiers[] = {
|
|
DRM_FORMAT_MOD_VIVANTE_TILED,
|
|
DRM_FORMAT_MOD_VIVANTE_SUPER_TILED,
|
|
DRM_FORMAT_MOD_VIVANTE_SUPER_TILED_FC,
|
|
DRM_FORMAT_MOD_LINEAR,
|
|
DRM_FORMAT_MOD_INVALID,
|
|
};
|
|
|
|
static inline struct dcss_plane *to_dcss_plane(struct drm_plane *p)
|
|
{
|
|
return container_of(p, struct dcss_plane, base);
|
|
}
|
|
|
|
static inline bool dcss_plane_fb_is_linear(const struct drm_framebuffer *fb)
|
|
{
|
|
return ((fb->flags & DRM_MODE_FB_MODIFIERS) == 0) ||
|
|
((fb->flags & DRM_MODE_FB_MODIFIERS) != 0 &&
|
|
fb->modifier == DRM_FORMAT_MOD_LINEAR);
|
|
}
|
|
|
|
static void dcss_plane_destroy(struct drm_plane *plane)
|
|
{
|
|
struct dcss_plane *dcss_plane = container_of(plane, struct dcss_plane,
|
|
base);
|
|
|
|
drm_plane_cleanup(plane);
|
|
kfree(dcss_plane);
|
|
}
|
|
|
|
static int dcss_plane_atomic_set_property(struct drm_plane *plane,
|
|
struct drm_plane_state *state,
|
|
struct drm_property *property,
|
|
uint64_t val)
|
|
{
|
|
struct dcss_plane *dcss_plane = to_dcss_plane(plane);
|
|
|
|
if (property == dcss_plane->dtrc_table_ofs_prop)
|
|
dcss_plane->dtrc_table_ofs_val = val;
|
|
else
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dcss_plane_atomic_get_property(struct drm_plane *plane,
|
|
const struct drm_plane_state *state,
|
|
struct drm_property *property,
|
|
uint64_t *val)
|
|
{
|
|
struct dcss_plane *dcss_plane = to_dcss_plane(plane);
|
|
|
|
if (property == dcss_plane->dtrc_table_ofs_prop)
|
|
*val = dcss_plane->dtrc_table_ofs_val;
|
|
else
|
|
return -EINVAL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static bool dcss_plane_format_mod_supported(struct drm_plane *plane,
|
|
u32 format,
|
|
u64 modifier)
|
|
{
|
|
switch (plane->type) {
|
|
case DRM_PLANE_TYPE_PRIMARY:
|
|
switch (format) {
|
|
case DRM_FORMAT_ARGB8888:
|
|
case DRM_FORMAT_XRGB8888:
|
|
case DRM_FORMAT_ARGB2101010:
|
|
return modifier == DRM_FORMAT_MOD_LINEAR ||
|
|
modifier == DRM_FORMAT_MOD_VIVANTE_TILED ||
|
|
modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED ||
|
|
modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED_FC;
|
|
default:
|
|
return modifier == DRM_FORMAT_MOD_LINEAR;
|
|
}
|
|
break;
|
|
case DRM_PLANE_TYPE_OVERLAY:
|
|
switch (format) {
|
|
case DRM_FORMAT_NV12:
|
|
case DRM_FORMAT_NV21:
|
|
case DRM_FORMAT_NV12_10LE40:
|
|
return modifier == DRM_FORMAT_MOD_LINEAR ||
|
|
modifier == DRM_FORMAT_MOD_VSI_G1_TILED ||
|
|
modifier == DRM_FORMAT_MOD_VSI_G2_TILED ||
|
|
modifier == DRM_FORMAT_MOD_VSI_G2_TILED_COMPRESSED;
|
|
default:
|
|
return modifier == DRM_FORMAT_MOD_LINEAR;
|
|
}
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static const struct drm_plane_funcs dcss_plane_funcs = {
|
|
.update_plane = drm_atomic_helper_update_plane,
|
|
.disable_plane = drm_atomic_helper_disable_plane,
|
|
.destroy = dcss_plane_destroy,
|
|
.reset = drm_atomic_helper_plane_reset,
|
|
.atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state,
|
|
.atomic_destroy_state = drm_atomic_helper_plane_destroy_state,
|
|
.atomic_set_property = dcss_plane_atomic_set_property,
|
|
.atomic_get_property = dcss_plane_atomic_get_property,
|
|
.format_mod_supported = dcss_plane_format_mod_supported,
|
|
};
|
|
|
|
static bool dcss_plane_can_rotate(const struct drm_format_info *format,
|
|
bool mod_present, u64 modifier,
|
|
unsigned int rotation)
|
|
{
|
|
bool linear_format = !mod_present ||
|
|
(mod_present && modifier == DRM_FORMAT_MOD_LINEAR);
|
|
u32 supported_rotation = DRM_MODE_ROTATE_0;
|
|
|
|
if (!format->is_yuv && linear_format)
|
|
supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 |
|
|
DRM_MODE_REFLECT_MASK;
|
|
else if (!format->is_yuv &&
|
|
modifier == DRM_FORMAT_MOD_VIVANTE_TILED)
|
|
supported_rotation = DRM_MODE_ROTATE_MASK |
|
|
DRM_MODE_REFLECT_MASK;
|
|
else if (format->is_yuv && linear_format &&
|
|
(format->format == DRM_FORMAT_NV12 ||
|
|
format->format == DRM_FORMAT_NV21))
|
|
supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_ROTATE_180 |
|
|
DRM_MODE_REFLECT_MASK;
|
|
else if (format->is_yuv && linear_format &&
|
|
format->format == DRM_FORMAT_NV12_10LE40)
|
|
supported_rotation = DRM_MODE_ROTATE_0 | DRM_MODE_REFLECT_Y;
|
|
|
|
return !!(rotation & supported_rotation);
|
|
}
|
|
|
|
static bool dcss_plane_is_source_size_allowed(u16 src_w, u16 src_h, u32 pix_fmt)
|
|
{
|
|
if (src_w < 64 &&
|
|
(pix_fmt == DRM_FORMAT_NV12 || pix_fmt == DRM_FORMAT_NV21 ||
|
|
pix_fmt == DRM_FORMAT_NV12_10LE40))
|
|
return false;
|
|
else if (src_w < 32 &&
|
|
(pix_fmt == DRM_FORMAT_UYVY || pix_fmt == DRM_FORMAT_VYUY ||
|
|
pix_fmt == DRM_FORMAT_YUYV || pix_fmt == DRM_FORMAT_YVYU))
|
|
return false;
|
|
|
|
return src_w >= 16 && src_h >= 8;
|
|
}
|
|
|
|
static inline bool dcss_plane_use_dtrc(struct drm_framebuffer *fb,
|
|
enum drm_plane_type type)
|
|
{
|
|
u64 pix_format = fb->format->format;
|
|
|
|
return !dcss_plane_fb_is_linear(fb) &&
|
|
type == DRM_PLANE_TYPE_OVERLAY &&
|
|
(pix_format == DRM_FORMAT_NV12 ||
|
|
pix_format == DRM_FORMAT_NV21 ||
|
|
pix_format == DRM_FORMAT_NV12_10LE40);
|
|
}
|
|
|
|
static int dcss_plane_atomic_check(struct drm_plane *plane,
|
|
struct drm_plane_state *state)
|
|
{
|
|
struct dcss_plane *dcss_plane = to_dcss_plane(plane);
|
|
struct dcss_dev *dcss = plane->dev->dev_private;
|
|
struct drm_framebuffer *fb = state->fb;
|
|
bool is_primary_plane = plane->type == DRM_PLANE_TYPE_PRIMARY;
|
|
struct drm_gem_cma_object *cma_obj;
|
|
struct drm_crtc_state *crtc_state;
|
|
int hdisplay, vdisplay;
|
|
int min, max;
|
|
int ret;
|
|
|
|
if (!fb || !state->crtc)
|
|
return 0;
|
|
|
|
cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
|
|
WARN_ON(!cma_obj);
|
|
|
|
crtc_state = drm_atomic_get_existing_crtc_state(state->state,
|
|
state->crtc);
|
|
|
|
hdisplay = crtc_state->adjusted_mode.hdisplay;
|
|
vdisplay = crtc_state->adjusted_mode.vdisplay;
|
|
|
|
if (!dcss_plane_is_source_size_allowed(state->src_w >> 16,
|
|
state->src_h >> 16,
|
|
fb->format->format)) {
|
|
DRM_DEBUG_KMS("Source plane size is not allowed!\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
dcss_scaler_get_min_max_ratios(dcss->scaler, dcss_plane->ch_num,
|
|
&min, &max);
|
|
|
|
ret = drm_atomic_helper_check_plane_state(state, crtc_state,
|
|
min, max, !is_primary_plane,
|
|
false);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (!state->visible)
|
|
return 0;
|
|
|
|
if (!dcss_plane_can_rotate(fb->format,
|
|
!!(fb->flags & DRM_MODE_FB_MODIFIERS),
|
|
fb->modifier,
|
|
state->rotation)) {
|
|
DRM_DEBUG_KMS("requested rotation is not allowed!\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if ((fb->flags & DRM_MODE_FB_MODIFIERS) &&
|
|
!plane->funcs->format_mod_supported(plane,
|
|
fb->format->format,
|
|
fb->modifier)) {
|
|
DRM_DEBUG_KMS("Invalid modifier: %llx", fb->modifier);
|
|
return -EINVAL;
|
|
}
|
|
|
|
dcss_plane->use_dtrc = dcss_plane_use_dtrc(fb, plane->type);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static struct drm_gem_object *dcss_plane_gem_import(struct drm_device *dev,
|
|
struct dma_buf *dma_buf)
|
|
{
|
|
struct drm_gem_object *obj;
|
|
|
|
if (IS_ERR(dma_buf))
|
|
return ERR_CAST(dma_buf);
|
|
|
|
mutex_lock(&dev->object_name_lock);
|
|
|
|
obj = dev->driver->gem_prime_import(dev, dma_buf);
|
|
|
|
mutex_unlock(&dev->object_name_lock);
|
|
|
|
return obj;
|
|
}
|
|
|
|
static void dcss_plane_set_primary_base(struct dcss_plane *dcss_plane,
|
|
u32 baddr)
|
|
{
|
|
struct drm_plane *plane = &dcss_plane->base;
|
|
struct dcss_dev *dcss = plane->dev->dev_private;
|
|
struct drm_plane_state *state = plane->state;
|
|
struct drm_framebuffer *fb = state->fb;
|
|
struct drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
|
|
struct dma_buf *dma_buf = cma_obj->base.dma_buf;
|
|
struct drm_gem_object *gem_obj;
|
|
dma_addr_t caddr;
|
|
bool compressed = true;
|
|
u32 compressed_format = _VIV_CFMT_ARGB8;
|
|
_VIV_VIDMEM_METADATA *mdata;
|
|
|
|
if (dcss_plane_fb_is_linear(fb) ||
|
|
((fb->flags & DRM_MODE_FB_MODIFIERS) &&
|
|
(fb->modifier == DRM_FORMAT_MOD_VIVANTE_TILED ||
|
|
fb->modifier == DRM_FORMAT_MOD_VIVANTE_SUPER_TILED))) {
|
|
dcss_dec400d_bypass(dcss->dec400d);
|
|
return;
|
|
}
|
|
|
|
if (!dma_buf) {
|
|
caddr = cma_obj->paddr + ALIGN(fb->height, 64) * fb->pitches[0];
|
|
} else {
|
|
mdata = dma_buf->priv;
|
|
if (!mdata || mdata->magic != VIV_VIDMEM_METADATA_MAGIC)
|
|
return;
|
|
|
|
gem_obj = dcss_plane_gem_import(plane->dev, mdata->ts_dma_buf);
|
|
if (IS_ERR(gem_obj))
|
|
return;
|
|
|
|
caddr = to_drm_gem_cma_obj(gem_obj)->paddr;
|
|
|
|
/* release gem_obj */
|
|
drm_gem_object_put_unlocked(gem_obj);
|
|
|
|
dcss_dec400d_fast_clear_config(dcss->dec400d, mdata->fc_value,
|
|
mdata->fc_enabled);
|
|
|
|
compressed = !!mdata->compressed;
|
|
compressed_format = mdata->compress_format;
|
|
}
|
|
|
|
dcss_dec400d_read_config(dcss->dec400d, 0, compressed,
|
|
compressed_format);
|
|
dcss_dec400d_addr_set(dcss->dec400d, baddr, caddr);
|
|
}
|
|
|
|
static void dcss_plane_set_dtrc_base(struct dcss_plane *dcss_plane,
|
|
u32 p1_ba, u32 p2_ba)
|
|
{
|
|
struct drm_plane *plane = &dcss_plane->base;
|
|
struct dcss_dev *dcss = plane->dev->dev_private;
|
|
|
|
if (!dcss_plane->use_dtrc) {
|
|
dcss_dtrc_bypass(dcss->dtrc, dcss_plane->ch_num);
|
|
return;
|
|
}
|
|
|
|
dcss_dtrc_addr_set(dcss->dtrc, dcss_plane->ch_num,
|
|
p1_ba, p2_ba, dcss_plane->dtrc_table_ofs_val);
|
|
}
|
|
|
|
static void dcss_plane_atomic_set_base(struct dcss_plane *dcss_plane)
|
|
{
|
|
struct drm_plane *plane = &dcss_plane->base;
|
|
struct drm_plane_state *state = plane->state;
|
|
struct dcss_dev *dcss = plane->dev->dev_private;
|
|
struct drm_framebuffer *fb = state->fb;
|
|
const struct drm_format_info *format = fb->format;
|
|
struct drm_gem_cma_object *cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
|
|
unsigned long p1_ba = 0, p2_ba = 0;
|
|
u16 x1, y1;
|
|
|
|
x1 = state->src.x1 >> 16;
|
|
y1 = state->src.y1 >> 16;
|
|
|
|
if (!format->is_yuv ||
|
|
format->format == DRM_FORMAT_NV12 ||
|
|
format->format == DRM_FORMAT_NV21)
|
|
p1_ba = cma_obj->paddr + fb->offsets[0] +
|
|
fb->pitches[0] * y1 +
|
|
format->char_per_block[0] * x1;
|
|
else if (format->format == DRM_FORMAT_NV12_10LE40)
|
|
p1_ba = cma_obj->paddr + fb->offsets[0] +
|
|
fb->pitches[0] * y1 +
|
|
format->char_per_block[0] * (x1 >> 2);
|
|
else if (format->format == DRM_FORMAT_UYVY ||
|
|
format->format == DRM_FORMAT_VYUY ||
|
|
format->format == DRM_FORMAT_YUYV ||
|
|
format->format == DRM_FORMAT_YVYU)
|
|
p1_ba = cma_obj->paddr + fb->offsets[0] +
|
|
fb->pitches[0] * y1 +
|
|
2 * format->char_per_block[0] * (x1 >> 1);
|
|
|
|
if (format->format == DRM_FORMAT_NV12 ||
|
|
format->format == DRM_FORMAT_NV21)
|
|
p2_ba = cma_obj->paddr + fb->offsets[1] +
|
|
(((fb->pitches[1] >> 1) * (y1 >> 1) +
|
|
(x1 >> 1)) << 1);
|
|
else if (format->format == DRM_FORMAT_NV12_10LE40)
|
|
p2_ba = cma_obj->paddr + fb->offsets[1] +
|
|
(((fb->pitches[1] >> 1) * (y1 >> 1)) << 1) +
|
|
format->char_per_block[1] * (x1 >> 2);
|
|
|
|
dcss_dpr_addr_set(dcss->dpr, dcss_plane->ch_num, p1_ba, p2_ba,
|
|
fb->pitches[0]);
|
|
|
|
if (plane->type == DRM_PLANE_TYPE_PRIMARY)
|
|
dcss_plane_set_primary_base(dcss_plane, p1_ba);
|
|
else
|
|
dcss_plane_set_dtrc_base(dcss_plane,
|
|
cma_obj->paddr + fb->offsets[0],
|
|
cma_obj->paddr + fb->offsets[1]);
|
|
}
|
|
|
|
static bool dcss_plane_needs_setup(struct drm_plane_state *state,
|
|
struct drm_plane_state *old_state)
|
|
{
|
|
struct drm_framebuffer *fb = state->fb;
|
|
struct drm_framebuffer *old_fb = old_state->fb;
|
|
|
|
return state->crtc_x != old_state->crtc_x ||
|
|
state->crtc_y != old_state->crtc_y ||
|
|
state->crtc_w != old_state->crtc_w ||
|
|
state->crtc_h != old_state->crtc_h ||
|
|
state->src_x != old_state->src_x ||
|
|
state->src_y != old_state->src_y ||
|
|
state->src_w != old_state->src_w ||
|
|
state->src_h != old_state->src_h ||
|
|
fb->format->format != old_fb->format->format ||
|
|
fb->modifier != old_fb->modifier ||
|
|
state->rotation != old_state->rotation;
|
|
}
|
|
|
|
static void dcss_plane_setup_hdr10_pipes(struct drm_plane *plane)
|
|
{
|
|
struct dcss_dev *dcss = plane->dev->dev_private;
|
|
struct dcss_plane *dcss_plane = to_dcss_plane(plane);
|
|
struct drm_plane_state *state = plane->state;
|
|
struct drm_crtc *crtc = state->crtc;
|
|
struct dcss_crtc *dcss_crtc = container_of(crtc, struct dcss_crtc,
|
|
base);
|
|
struct drm_framebuffer *fb = state->fb;
|
|
struct dcss_hdr10_pipe_cfg ipipe_cfg, opipe_cfg;
|
|
|
|
opipe_cfg.is_yuv = dcss_crtc->output_is_yuv;
|
|
opipe_cfg.g = dcss_crtc->opipe_g;
|
|
opipe_cfg.nl = dcss_crtc->opipe_nl;
|
|
opipe_cfg.pr = dcss_crtc->opipe_pr;
|
|
|
|
ipipe_cfg.is_yuv = fb->format->is_yuv;
|
|
|
|
if (!fb->format->is_yuv) {
|
|
ipipe_cfg.nl = NL_SRGB;
|
|
ipipe_cfg.pr = PR_FULL;
|
|
ipipe_cfg.g = G_ADOBE_ARGB;
|
|
goto setup;
|
|
}
|
|
|
|
switch (state->color_encoding) {
|
|
case DRM_COLOR_YCBCR_BT709:
|
|
ipipe_cfg.nl = NL_REC709;
|
|
ipipe_cfg.g = G_REC709;
|
|
break;
|
|
|
|
case DRM_COLOR_YCBCR_BT2020:
|
|
ipipe_cfg.nl = NL_REC2084;
|
|
ipipe_cfg.g = G_REC2020;
|
|
break;
|
|
|
|
default:
|
|
ipipe_cfg.nl = NL_REC709;
|
|
ipipe_cfg.g = G_REC601_PAL;
|
|
break;
|
|
}
|
|
|
|
ipipe_cfg.pr = state->color_range;
|
|
|
|
setup:
|
|
dcss_hdr10_setup(dcss->hdr10, dcss_plane->ch_num,
|
|
&ipipe_cfg, &opipe_cfg);
|
|
}
|
|
|
|
static void dcss_plane_atomic_update(struct drm_plane *plane,
|
|
struct drm_plane_state *old_state)
|
|
{
|
|
struct drm_plane_state *state = plane->state;
|
|
struct dcss_plane *dcss_plane = to_dcss_plane(plane);
|
|
struct dcss_dev *dcss = plane->dev->dev_private;
|
|
struct drm_framebuffer *fb = state->fb;
|
|
u32 pixel_format;
|
|
struct drm_crtc_state *crtc_state;
|
|
bool modifiers_present;
|
|
u32 src_w, src_h, dst_w, dst_h;
|
|
struct drm_rect src, dst;
|
|
bool enable = true;
|
|
|
|
if (!fb || !state->crtc || !state->visible)
|
|
return;
|
|
|
|
pixel_format = fb->format->format;
|
|
crtc_state = state->crtc->state;
|
|
modifiers_present = !!(fb->flags & DRM_MODE_FB_MODIFIERS);
|
|
|
|
if (old_state->fb && !drm_atomic_crtc_needs_modeset(crtc_state) &&
|
|
!dcss_plane_needs_setup(state, old_state) &&
|
|
!dcss_dtg_global_alpha_changed(dcss->dtg, dcss_plane->ch_num,
|
|
state->alpha >> 8)) {
|
|
dcss_plane_atomic_set_base(dcss_plane);
|
|
if (plane->type == DRM_PLANE_TYPE_PRIMARY)
|
|
dcss_dec400d_shadow_trig(dcss->dec400d);
|
|
return;
|
|
}
|
|
|
|
src = plane->state->src;
|
|
dst = plane->state->dst;
|
|
|
|
/*
|
|
* The width and height after clipping.
|
|
*/
|
|
src_w = drm_rect_width(&src) >> 16;
|
|
src_h = drm_rect_height(&src) >> 16;
|
|
dst_w = drm_rect_width(&dst);
|
|
dst_h = drm_rect_height(&dst);
|
|
|
|
dcss_dpr_format_set(dcss->dpr, dcss_plane->ch_num, state->fb->format,
|
|
modifiers_present ? fb->modifier :
|
|
DRM_FORMAT_MOD_LINEAR);
|
|
|
|
if (dcss_plane->use_dtrc) {
|
|
u32 dtrc_w, dtrc_h;
|
|
|
|
dcss_dtrc_set_res(dcss->dtrc, dcss_plane->ch_num, state,
|
|
&dtrc_w, &dtrc_h);
|
|
dcss_dpr_set_res(dcss->dpr, dcss_plane->ch_num, dtrc_w, dtrc_h);
|
|
} else {
|
|
dcss_dpr_set_res(dcss->dpr, dcss_plane->ch_num, src_w, src_h);
|
|
}
|
|
|
|
dcss_dpr_set_rotation(dcss->dpr, dcss_plane->ch_num,
|
|
state->rotation);
|
|
|
|
dcss_plane_atomic_set_base(dcss_plane);
|
|
|
|
dcss_scaler_setup(dcss->scaler, dcss_plane->ch_num,
|
|
state->fb->format, src_w, src_h,
|
|
dst_w, dst_h,
|
|
drm_mode_vrefresh(&crtc_state->mode));
|
|
|
|
dcss_plane_setup_hdr10_pipes(plane);
|
|
|
|
dcss_dtg_plane_pos_set(dcss->dtg, dcss_plane->ch_num,
|
|
dst.x1, dst.y1, dst_w, dst_h);
|
|
dcss_dtg_plane_alpha_set(dcss->dtg, dcss_plane->ch_num,
|
|
fb->format, state->alpha >> 8);
|
|
|
|
if (plane->type == DRM_PLANE_TYPE_PRIMARY)
|
|
dcss_dec400d_enable(dcss->dec400d);
|
|
else if (dcss_plane->use_dtrc)
|
|
dcss_dtrc_enable(dcss->dtrc, dcss_plane->ch_num, true);
|
|
|
|
if (!dcss_plane->ch_num && (state->alpha >> 8) == 0)
|
|
enable = false;
|
|
|
|
dcss_dpr_enable(dcss->dpr, dcss_plane->ch_num, enable);
|
|
dcss_scaler_ch_enable(dcss->scaler, dcss_plane->ch_num, enable);
|
|
|
|
if (!enable)
|
|
dcss_dtg_plane_pos_set(dcss->dtg, dcss_plane->ch_num,
|
|
0, 0, 0, 0);
|
|
|
|
dcss_dtg_ch_enable(dcss->dtg, dcss_plane->ch_num, enable);
|
|
}
|
|
|
|
static void dcss_plane_atomic_disable(struct drm_plane *plane,
|
|
struct drm_plane_state *old_state)
|
|
{
|
|
struct dcss_plane *dcss_plane = to_dcss_plane(plane);
|
|
struct dcss_dev *dcss = plane->dev->dev_private;
|
|
|
|
if (dcss_plane->use_dtrc)
|
|
dcss_dtrc_enable(dcss->dtrc, dcss_plane->ch_num, false);
|
|
dcss_dpr_enable(dcss->dpr, dcss_plane->ch_num, false);
|
|
dcss_scaler_ch_enable(dcss->scaler, dcss_plane->ch_num, false);
|
|
dcss_dtg_plane_pos_set(dcss->dtg, dcss_plane->ch_num, 0, 0, 0, 0);
|
|
dcss_dtg_ch_enable(dcss->dtg, dcss_plane->ch_num, false);
|
|
}
|
|
|
|
static const struct drm_plane_helper_funcs dcss_plane_helper_funcs = {
|
|
.prepare_fb = drm_gem_fb_prepare_fb,
|
|
.atomic_check = dcss_plane_atomic_check,
|
|
.atomic_update = dcss_plane_atomic_update,
|
|
.atomic_disable = dcss_plane_atomic_disable,
|
|
};
|
|
|
|
struct dcss_plane *dcss_plane_init(struct drm_device *drm,
|
|
unsigned int possible_crtcs,
|
|
enum drm_plane_type type,
|
|
unsigned int zpos)
|
|
{
|
|
struct dcss_plane *dcss_plane;
|
|
const u64 *format_modifiers = dcss_video_format_modifiers;
|
|
const u32 *formats = dcss_video_formats;
|
|
u32 formats_size = ARRAY_SIZE(dcss_video_formats);
|
|
struct drm_property *prop;
|
|
int ret;
|
|
|
|
if (zpos > 2)
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
dcss_plane = kzalloc(sizeof(*dcss_plane), GFP_KERNEL);
|
|
if (!dcss_plane) {
|
|
DRM_ERROR("failed to allocate plane\n");
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
if (type == DRM_PLANE_TYPE_PRIMARY) {
|
|
formats = dcss_graphics_formats;
|
|
formats_size = ARRAY_SIZE(dcss_graphics_formats);
|
|
format_modifiers = dcss_graphics_format_modifiers;
|
|
}
|
|
|
|
ret = drm_universal_plane_init(drm, &dcss_plane->base, possible_crtcs,
|
|
&dcss_plane_funcs, formats,
|
|
formats_size,
|
|
format_modifiers, type, NULL);
|
|
if (ret) {
|
|
DRM_ERROR("failed to initialize plane\n");
|
|
kfree(dcss_plane);
|
|
return ERR_PTR(ret);
|
|
}
|
|
|
|
drm_plane_helper_add(&dcss_plane->base, &dcss_plane_helper_funcs);
|
|
|
|
ret = drm_plane_create_zpos_immutable_property(&dcss_plane->base, zpos);
|
|
if (ret)
|
|
return ERR_PTR(ret);
|
|
|
|
drm_plane_create_rotation_property(&dcss_plane->base,
|
|
DRM_MODE_ROTATE_0,
|
|
DRM_MODE_ROTATE_0 |
|
|
DRM_MODE_ROTATE_90 |
|
|
DRM_MODE_ROTATE_180 |
|
|
DRM_MODE_ROTATE_270 |
|
|
DRM_MODE_REFLECT_X |
|
|
DRM_MODE_REFLECT_Y);
|
|
|
|
dcss_plane->ch_num = 2 - zpos;
|
|
dcss_plane->type = type;
|
|
|
|
if (type == DRM_PLANE_TYPE_PRIMARY)
|
|
return dcss_plane;
|
|
|
|
prop = drm_property_create_range(drm, 0, "dtrc_table_ofs",
|
|
0, ULLONG_MAX);
|
|
if (!prop) {
|
|
DRM_ERROR("cannot create dtrc_table_ofs property\n");
|
|
return ERR_PTR(-ENOMEM);
|
|
}
|
|
|
|
dcss_plane->dtrc_table_ofs_prop = prop;
|
|
drm_object_attach_property(&dcss_plane->base.base, prop, 0);
|
|
|
|
return dcss_plane;
|
|
}
|