---
drivers/gpu/drm/vkms/Makefile | 1 +
drivers/gpu/drm/vkms/vkms_composer.c | 335 +++++++++++++--------------
drivers/gpu/drm/vkms/vkms_formats.c | 138 +++++++++++
drivers/gpu/drm/vkms/vkms_formats.h | 31 +++
4 files changed, 333 insertions(+), 172 deletions(-)
create mode 100644 drivers/gpu/drm/vkms/vkms_formats.c
create mode 100644 drivers/gpu/drm/vkms/vkms_formats.h
diff --git a/drivers/gpu/drm/vkms/Makefile b/drivers/gpu/drm/vkms/Makefile
index 72f779cbfedd..1b28a6a32948 100644
--- a/drivers/gpu/drm/vkms/Makefile
+++ b/drivers/gpu/drm/vkms/Makefile
@@ -3,6 +3,7 @@ vkms-y := \
vkms_drv.o \
vkms_plane.o \
vkms_output.o \
+ vkms_formats.o \
vkms_crtc.o \
vkms_composer.o \
vkms_writeback.o
diff --git a/drivers/gpu/drm/vkms/vkms_composer.c b/drivers/gpu/drm/vkms/vkms_composer.c
index 95029d2ebcac..9f70fcf84fb9 100644
--- a/drivers/gpu/drm/vkms/vkms_composer.c
+++ b/drivers/gpu/drm/vkms/vkms_composer.c
@@ -9,202 +9,210 @@
#include <drm/drm_vblank.h>
#include "vkms_drv.h"
+#include "vkms_formats.h"
-static u32 get_pixel_from_buffer(int x, int y, const u8 *buffer,
- const struct vkms_frame_info *frame_info)
+static u16 pre_mul_blend_channel(u16 src, u16 dst, u16 alpha)
{
- u32 pixel;
- int src_offset = frame_info->offset + (y * frame_info->pitch)
- + (x * frame_info->cpp);
+ u32 new_color;
- pixel = *(u32 *)&buffer[src_offset];
+ new_color = (src * 0xffff + dst * (0xffff - alpha));
- return pixel;
+ return DIV_ROUND_UP(new_color, 0xffff);
}
/**
- * compute_crc - Compute CRC value on output frame
+ * pre_mul_alpha_blend - alpha blending equation
+ * @src_frame_info: source framebuffer's metadata
+ * @stage_buffer: The line with the pixels from src_plane
+ * @output_buffer: A line buffer that receives all the blends output
*
- * @vaddr: address to final framebuffer
- * @frame_info: framebuffer's metadata
+ * Using the information from the `frame_info`, this blends only the
+ * necessary pixels from the `stage_buffer` to the `output_buffer`
+ * using premultiplied blend formula.
*
- * returns CRC value computed using crc32 on the visible portion of
- * the final framebuffer at vaddr_out
+ * The current DRM assumption is that pixel color values have been already
+ * pre-multiplied with the alpha channel values. See more
+ * drm_plane_create_blend_mode_property(). Also, this formula assumes a
+ * completely opaque background.
*/
-static uint32_t compute_crc(const u8 *vaddr,
- const struct vkms_frame_info *frame_info)
+static void pre_mul_alpha_blend(struct vkms_frame_info *frame_info,
+ struct line_buffer *stage_buffer,
+ struct line_buffer *output_buffer)
{
- int x, y;
- u32 crc = 0, pixel = 0;
- int x_src = frame_info->src.x1 >> 16;
- int y_src = frame_info->src.y1 >> 16;
- int h_src = drm_rect_height(&frame_info->src) >> 16;
- int w_src = drm_rect_width(&frame_info->src) >> 16;
-
- for (y = y_src; y < y_src + h_src; ++y) {
- for (x = x_src; x < x_src + w_src; ++x) {
- pixel = get_pixel_from_buffer(x, y, vaddr, frame_info);
- crc = crc32_le(crc, (void *)&pixel, sizeof(u32));
- }
+ int x, x_dst = frame_info->dst.x1;
+ int x_limit = drm_rect_width(&frame_info->dst);
+ struct line_buffer *out = output_buffer + x_dst;
+ struct line_buffer *in = stage_buffer;
+
+ for (x = 0; x < x_limit; x++) {
+ out[x].a = (u16)0xffff;
+ out[x].r = pre_mul_blend_channel(in[x].r, out[x].r, in[x].a);
+ out[x].g = pre_mul_blend_channel(in[x].g, out[x].g, in[x].a);
+ out[x].b = pre_mul_blend_channel(in[x].b, out[x].b, in[x].a);
}
-
- return crc;
}
-static u8 blend_channel(u8 src, u8 dst, u8 alpha)
+static bool check_y_limit(struct vkms_frame_info *frame_info, int y)
{
- u32 pre_blend;
- u8 new_color;
-
- pre_blend = (src * 255 + dst * (255 - alpha));
-
- /* Faster div by 255 */
- new_color = ((pre_blend + ((pre_blend + 257) >> 8)) >> 8);
+ if (y >= frame_info->dst.y1 && y < frame_info->dst.y2)
+ return true;
- return new_color;
+ return false;
}
/**
- * alpha_blend - alpha blending equation
- * @argb_src: src pixel on premultiplied alpha mode
- * @argb_dst: dst pixel completely opaque
- *
- * blend pixels using premultiplied blend formula. The current DRM assumption
- * is that pixel color values have been already pre-multiplied with the alpha
- * channel values. See more drm_plane_create_blend_mode_property(). Also, this
- * formula assumes a completely opaque background.
- */
-static void alpha_blend(const u8 *argb_src, u8 *argb_dst)
-{
- u8 alpha;
-
- alpha = argb_src[3];
- argb_dst[0] = blend_channel(argb_src[0], argb_dst[0], alpha);
- argb_dst[1] = blend_channel(argb_src[1], argb_dst[1], alpha);
- argb_dst[2] = blend_channel(argb_src[2], argb_dst[2], alpha);
-}
-
-/**
- * x_blend - blending equation that ignores the pixel alpha
- *
- * overwrites RGB color value from src pixel to dst pixel.
- */
-static void x_blend(const u8 *xrgb_src, u8 *xrgb_dst)
-{
- memcpy(xrgb_dst, xrgb_src, sizeof(u8) * 3);
-}
-
-/**
- * blend - blend value at vaddr_src with value at vaddr_dst
- * @vaddr_dst: destination address
- * @vaddr_src: source address
- * @dst_frame_info: destination framebuffer's metadata
- * @src_frame_info: source framebuffer's metadata
- * @pixel_blend: blending equation based on plane format
+ * @wb_frame_info: The writeback frame buffer metadata
+ * @wb_fmt_func: The format tranformatio function to the wb buffer
+ * @crtc_state: The crtc state
+ * @plane_fmt_func: A format tranformation function to each plane
+ * @crc32: The crc output of the final frame
+ * @output_buffer: A buffer of a row that will receive the result of the blend(s)
+ * @stage_buffer: The line with the pixels from src_compositor
*
- * Blend the vaddr_src value with the vaddr_dst value using a pixel blend
- * equation according to the supported plane formats DRM_FORMAT_(A/XRGB8888)
- * and clearing alpha channel to an completely opaque background. This function
- * uses buffer's metadata to locate the new composite values at vaddr_dst.
+ * This function blends the pixels (Using the `pre_mul_alpha_blend`)
+ * from all planes, calculates the crc32 of the output from the former step,
+ * and, if necessary, convert and store the output to the writeback buffer.
*
* TODO: completely clear the primary plane (a = 0xff) before starting to blend
* pixel color values
*/
-static void blend(void *vaddr_dst, void *vaddr_src,
- struct vkms_frame_info *dst_frame_info,
- struct vkms_frame_info *src_frame_info,
- void (*pixel_blend)(const u8 *, u8 *))
+static void blend(struct vkms_frame_info *wb_frame_info,
+ format_transform_func wb_fmt_func,
+ struct vkms_crtc_state *crtc_state,
+ format_transform_func *plane_fmt_func,
+ u32 *crc32, struct line_buffer *stage_buffer,
+ struct line_buffer *output_buffer, s64 row_size)
{
- int i, j, j_dst, i_dst;
- int offset_src, offset_dst;
- u8 *pixel_dst, *pixel_src;
-
- int x_src = src_frame_info->src.x1 >> 16;
- int y_src = src_frame_info->src.y1 >> 16;
-
- int x_dst = src_frame_info->dst.x1;
- int y_dst = src_frame_info->dst.y1;
- int h_dst = drm_rect_height(&src_frame_info->dst);
- int w_dst = drm_rect_width(&src_frame_info->dst);
+ struct vkms_plane_state **plane = crtc_state->active_planes;
+ struct vkms_frame_info *primary_plane_info = plane[0]->frame_info;
+ u32 n_active_planes = crtc_state->num_active_planes;
+ int y_src = primary_plane_info->dst.y1;
+ int h_dst = drm_rect_height(&primary_plane_info->dst);
int y_limit = y_src + h_dst;
- int x_limit = x_src + w_dst;
-
- for (i = y_src, i_dst = y_dst; i < y_limit; ++i) {
- for (j = x_src, j_dst = x_dst; j < x_limit; ++j) {
- offset_dst = dst_frame_info->offset
- + (i_dst * dst_frame_info->pitch)
- + (j_dst++ * dst_frame_info->cpp);
- offset_src = src_frame_info->offset
- + (i * src_frame_info->pitch)
- + (j * src_frame_info->cpp);
-
- pixel_src = (u8 *)(vaddr_src + offset_src);
- pixel_dst = (u8 *)(vaddr_dst + offset_dst);
- pixel_blend(pixel_src, pixel_dst);
- /* clearing alpha channel (0xff)*/
- pixel_dst[3] = 0xff;
+ int y, i;
+
+ for (y = y_src; y < y_limit; y++) {
+ plane_fmt_func[0](primary_plane_info, y, output_buffer);
+
+ /* If there are other planes besides primary, we consider the active
+ * planes should be in z-order and compose them associatively:
+ * ((primary <- overlay) <- cursor)
+ */
+ for (i = 1; i < n_active_planes; i++) {
+ if (!check_y_limit(plane[i]->frame_info, y))
+ continue;
+
+ plane_fmt_func[i](plane[i]->frame_info, y, stage_buffer);
+ pre_mul_alpha_blend(plane[i]->frame_info, stage_buffer,
+ output_buffer);
}
- i_dst++;
+
+ *crc32 = crc32_le(*crc32, (void *)output_buffer, row_size);
+
+ if (wb_frame_info)
+ wb_fmt_func(wb_frame_info, y, output_buffer);
}
}
-static void compose_plane(struct vkms_frame_info *primary_plane_info,
- struct vkms_frame_info *plane_frame_info,
- void *vaddr_out)
+static void get_format_transform_functions(struct vkms_crtc_state *crtc_state,
+ format_transform_func plane_funcs[])
{
- struct drm_framebuffer *fb = plane_frame_info->fb;
- void *vaddr;
- void (*pixel_blend)(const u8 *p_src, u8 *p_dst);
+ struct vkms_plane_state **active_planes = crtc_state->active_planes;
+ u32 n_active_planes = crtc_state->num_active_planes, s_fmt;
+ int i;
- if (WARN_ON(dma_buf_map_is_null(&primary_plane_info->map[0])))
- return;
+ for (i = 0; i < n_active_planes; i++) {
+ s_fmt = active_planes[i]->frame_info->fb->format->format;
+ plane_funcs[i] = get_fmt_transform_function(s_fmt);
+ }
+}
- vaddr = plane_frame_info->map[0].vaddr;
+static bool check_planes_x_bounds(struct vkms_crtc_state *crtc_state,
+ struct vkms_frame_info *wb_frame_info)
+{
+ struct vkms_plane_state **planes = crtc_state->active_planes;
+ struct vkms_frame_info *primary_plane_info = planes[0]->frame_info;
+ int line_width = drm_rect_width(&primary_plane_info->dst);
+ u32 n_active_planes = crtc_state->num_active_planes;
+ int i;
- if (fb->format->format == DRM_FORMAT_ARGB8888)
- pixel_blend = &alpha_blend;
- else
- pixel_blend = &x_blend;
+ for (i = 0; i < n_active_planes; i++) {
+ int x_dst = planes[i]->frame_info->dst.x1;
+ int x_src = planes[i]->frame_info->src.x1 >> 16;
+ int x2_src = planes[i]->frame_info->src.x2 >> 16;
+ int x_limit = drm_rect_width(&planes[i]->frame_info->dst);
- blend(vaddr_out, vaddr, primary_plane_info,
- plane_frame_info, pixel_blend);
+ if (x_dst + x_limit > line_width)
+ return false;
+ if (x_src + x_limit > x2_src)
+ return false;
+ }
+
+ return true;
}
-static int compose_active_planes(void **vaddr_out,
- struct vkms_frame_info *primary_plane_info,
- struct vkms_crtc_state *crtc_state)
+static int compose_active_planes(struct vkms_frame_info *wb_frame_info,
+ struct vkms_crtc_state *crtc_state,
+ u32 *crc32)
{
- struct drm_framebuffer *fb = primary_plane_info->fb;
- struct drm_gem_object *gem_obj = drm_gem_fb_get_obj(fb, 0);
- const void *vaddr;
- int i;
+ format_transform_func plane_funcs[NUM_OVERLAY_PLANES], wb_func = NULL;
+ int line_width, ret = 0, pixel_size = sizeof(struct line_buffer);
+ struct vkms_frame_info *primary_plane_info = NULL;
+ struct line_buffer *output_buffer, *stage_buffer;
+ struct vkms_plane_state *act_plane = NULL;
+ u32 wb_format;
- if (!*vaddr_out) {
- *vaddr_out = kvzalloc(gem_obj->size, GFP_KERNEL);
- if (!*vaddr_out) {
- DRM_ERROR("Cannot allocate memory for output frame.");
- return -ENOMEM;
- }
+ if (WARN_ON(pixel_size != 8))
+ return -EINVAL;
+
+ if (crtc_state->num_active_planes >= 1) {
+ act_plane = crtc_state->active_planes[0];
+ if (act_plane->base.base.plane->type == DRM_PLANE_TYPE_PRIMARY)
+ primary_plane_info = act_plane->frame_info;
}
+ if (!primary_plane_info)
+ return -EINVAL;
+
if (WARN_ON(dma_buf_map_is_null(&primary_plane_info->map[0])))
return -EINVAL;
- vaddr = primary_plane_info->map[0].vaddr;
+ if (WARN_ON(!check_planes_x_bounds(crtc_state, wb_frame_info)))
+ return -EINVAL;
- memcpy(*vaddr_out, vaddr, gem_obj->size);
+ line_width = drm_rect_width(&primary_plane_info->dst);
- /* If there are other planes besides primary, we consider the active
- * planes should be in z-order and compose them associatively:
- * ((primary <- overlay) <- cursor)
- */
- for (i = 1; i < crtc_state->num_active_planes; i++)
- compose_plane(primary_plane_info,
- crtc_state->active_planes[i]->frame_info,
- *vaddr_out);
+ stage_buffer = kvmalloc(line_width * pixel_size, GFP_KERNEL);
+ if (!stage_buffer) {
+ DRM_ERROR("Cannot allocate memory for the output line buffer");
+ return -ENOMEM;
+ }
- return 0;
+ output_buffer = kvmalloc(line_width * pixel_size, GFP_KERNEL);
+ if (!output_buffer) {
+ DRM_ERROR("Cannot allocate memory for intermediate line buffer");
+ ret = -ENOMEM;
+ goto free_stage_buffer;
+ }
+
+ get_format_transform_functions(crtc_state, plane_funcs);
+
+ if (wb_frame_info) {
+ wb_format = wb_frame_info->fb->format->format;
+ wb_func = get_wb_fmt_transform_function(wb_format);
+ wb_frame_info->src = primary_plane_info->src;
+ wb_frame_info->dst = primary_plane_info->dst;
+ }
+
+ blend(wb_frame_info, wb_func, crtc_state, plane_funcs, crc32,
+ stage_buffer, output_buffer, (s64)line_width * pixel_size);
+
+ kvfree(output_buffer);
+free_stage_buffer:
+ kvfree(stage_buffer);
+
+ return ret;
}
/**
@@ -222,13 +230,12 @@ void vkms_composer_worker(struct work_struct *work)
struct vkms_crtc_state,
composer_work);
struct drm_crtc *crtc = crtc_state->base.crtc;
+ struct vkms_writeback_job *active_wb = crtc_state->active_writeback;
+ struct vkms_frame_info *wb_frame_info = &active_wb->frame_info;
struct vkms_output *out = drm_crtc_to_vkms_output(crtc);
- struct vkms_frame_info *primary_plane_info = NULL;
- struct vkms_plane_state *act_plane = NULL;
bool crc_pending, wb_pending;
- void *vaddr_out = NULL;
- u32 crc32 = 0;
u64 frame_start, frame_end;
+ u32 crc32 = 0;
int ret;
spin_lock_irq(&out->composer_lock);
@@ -248,35 +255,19 @@ void vkms_composer_worker(struct work_struct *work)
if (!crc_pending)
return;
- if (crtc_state->num_active_planes >= 1) {
- act_plane = crtc_state->active_planes[0];
- if (act_plane->base.base.plane->type == DRM_PLANE_TYPE_PRIMARY)
- primary_plane_info = act_plane->frame_info;
- }
-
- if (!primary_plane_info)
- return;
-
if (wb_pending)
- vaddr_out = crtc_state->active_writeback->data[0].vaddr;
+ ret = compose_active_planes(wb_frame_info, crtc_state, &crc32);
+ else
+ ret = compose_active_planes(NULL, crtc_state, &crc32);
- ret = compose_active_planes(&vaddr_out, primary_plane_info,
- crtc_state);
- if (ret) {
- if (ret == -EINVAL && !wb_pending)
- kvfree(vaddr_out);
+ if (ret)
return;
- }
-
- crc32 = compute_crc(vaddr_out, primary_plane_info);
if (wb_pending) {
drm_writeback_signal_completion(&out->wb_connector, 0);
spin_lock_irq(&out->composer_lock);
crtc_state->wb_pending = false;
spin_unlock_irq(&out->composer_lock);
- } else {
- kvfree(vaddr_out);
}
/*
diff --git a/drivers/gpu/drm/vkms/vkms_formats.c b/drivers/gpu/drm/vkms/vkms_formats.c
new file mode 100644
index 000000000000..0d1838d1b835
--- /dev/null
+++ b/drivers/gpu/drm/vkms/vkms_formats.c
@@ -0,0 +1,138 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
