2019-02-06 14:01:16 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
|
|
|
|
2018-08-02 01:10:26 +00:00
|
|
|
#include "vkms_drv.h"
|
|
|
|
#include <linux/crc32.h>
|
2018-09-06 05:18:26 +00:00
|
|
|
#include <drm/drm_atomic.h>
|
|
|
|
#include <drm/drm_atomic_helper.h>
|
2018-08-02 01:10:26 +00:00
|
|
|
#include <drm/drm_gem_framebuffer_helper.h>
|
|
|
|
|
2018-09-06 05:18:26 +00:00
|
|
|
/**
|
|
|
|
* compute_crc - Compute CRC value on output frame
|
|
|
|
*
|
|
|
|
* @vaddr_out: address to final framebuffer
|
|
|
|
* @crc_out: framebuffer's metadata
|
|
|
|
*
|
|
|
|
* returns CRC value computed using crc32 on the visible portion of
|
|
|
|
* the final framebuffer at vaddr_out
|
|
|
|
*/
|
|
|
|
static uint32_t compute_crc(void *vaddr_out, struct vkms_crc_data *crc_out)
|
|
|
|
{
|
|
|
|
int i, j, src_offset;
|
|
|
|
int x_src = crc_out->src.x1 >> 16;
|
|
|
|
int y_src = crc_out->src.y1 >> 16;
|
|
|
|
int h_src = drm_rect_height(&crc_out->src) >> 16;
|
|
|
|
int w_src = drm_rect_width(&crc_out->src) >> 16;
|
|
|
|
u32 crc = 0;
|
|
|
|
|
|
|
|
for (i = y_src; i < y_src + h_src; ++i) {
|
|
|
|
for (j = x_src; j < x_src + w_src; ++j) {
|
|
|
|
src_offset = crc_out->offset
|
|
|
|
+ (i * crc_out->pitch)
|
|
|
|
+ (j * crc_out->cpp);
|
|
|
|
/* XRGB format ignores Alpha channel */
|
|
|
|
memset(vaddr_out + src_offset + 24, 0, 8);
|
|
|
|
crc = crc32_le(crc, vaddr_out + src_offset,
|
|
|
|
sizeof(u32));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return crc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* blend - belnd value at vaddr_src with value at vaddr_dst
|
|
|
|
* @vaddr_dst: destination address
|
|
|
|
* @vaddr_src: source address
|
|
|
|
* @crc_dst: destination framebuffer's metadata
|
|
|
|
* @crc_src: source framebuffer's metadata
|
|
|
|
*
|
|
|
|
* Blend value at vaddr_src with value at vaddr_dst.
|
|
|
|
* Currently, this function write value at vaddr_src on value
|
|
|
|
* at vaddr_dst using buffer's metadata to locate the new values
|
|
|
|
* from vaddr_src and their distenation at vaddr_dst.
|
|
|
|
*
|
|
|
|
* Todo: Use the alpha value to blend vaddr_src with vaddr_dst
|
|
|
|
* instead of overwriting it.
|
|
|
|
*/
|
|
|
|
static void blend(void *vaddr_dst, void *vaddr_src,
|
|
|
|
struct vkms_crc_data *crc_dst,
|
|
|
|
struct vkms_crc_data *crc_src)
|
2018-08-02 01:10:26 +00:00
|
|
|
{
|
2018-09-06 05:18:26 +00:00
|
|
|
int i, j, j_dst, i_dst;
|
|
|
|
int offset_src, offset_dst;
|
|
|
|
|
|
|
|
int x_src = crc_src->src.x1 >> 16;
|
|
|
|
int y_src = crc_src->src.y1 >> 16;
|
|
|
|
|
|
|
|
int x_dst = crc_src->dst.x1;
|
|
|
|
int y_dst = crc_src->dst.y1;
|
|
|
|
int h_dst = drm_rect_height(&crc_src->dst);
|
|
|
|
int w_dst = drm_rect_width(&crc_src->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 = crc_dst->offset
|
|
|
|
+ (i_dst * crc_dst->pitch)
|
|
|
|
+ (j_dst++ * crc_dst->cpp);
|
|
|
|
offset_src = crc_src->offset
|
|
|
|
+ (i * crc_src->pitch)
|
|
|
|
+ (j * crc_src->cpp);
|
|
|
|
|
|
|
|
memcpy(vaddr_dst + offset_dst,
|
|
|
|
vaddr_src + offset_src, sizeof(u32));
|
|
|
|
}
|
|
|
|
i_dst++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void compose_cursor(struct vkms_crc_data *cursor_crc,
|
|
|
|
struct vkms_crc_data *primary_crc, void *vaddr_out)
|
|
|
|
{
|
|
|
|
struct drm_gem_object *cursor_obj;
|
|
|
|
struct vkms_gem_object *cursor_vkms_obj;
|
|
|
|
|
|
|
|
cursor_obj = drm_gem_fb_get_obj(&cursor_crc->fb, 0);
|
|
|
|
cursor_vkms_obj = drm_gem_to_vkms_gem(cursor_obj);
|
|
|
|
|
|
|
|
mutex_lock(&cursor_vkms_obj->pages_lock);
|
|
|
|
if (!cursor_vkms_obj->vaddr) {
|
|
|
|
DRM_WARN("cursor plane vaddr is NULL");
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
blend(vaddr_out, cursor_vkms_obj->vaddr, primary_crc, cursor_crc);
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&cursor_vkms_obj->pages_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static uint32_t _vkms_get_crc(struct vkms_crc_data *primary_crc,
|
|
|
|
struct vkms_crc_data *cursor_crc)
|
|
|
|
{
|
|
|
|
struct drm_framebuffer *fb = &primary_crc->fb;
|
2018-08-02 01:10:26 +00:00
|
|
|
struct drm_gem_object *gem_obj = drm_gem_fb_get_obj(fb, 0);
|
|
|
|
struct vkms_gem_object *vkms_obj = drm_gem_to_vkms_gem(gem_obj);
|
2018-09-06 05:18:26 +00:00
|
|
|
void *vaddr_out = kzalloc(vkms_obj->gem.size, GFP_KERNEL);
|
2018-08-02 01:10:26 +00:00
|
|
|
u32 crc = 0;
|
|
|
|
|
2018-09-06 05:18:26 +00:00
|
|
|
if (!vaddr_out) {
|
|
|
|
DRM_ERROR("Failed to allocate memory for output frame.");
|
|
|
|
return 0;
|
|
|
|
}
|
2018-08-02 01:10:26 +00:00
|
|
|
|
2018-09-06 05:18:26 +00:00
|
|
|
mutex_lock(&vkms_obj->pages_lock);
|
|
|
|
if (WARN_ON(!vkms_obj->vaddr)) {
|
|
|
|
mutex_unlock(&vkms_obj->pages_lock);
|
2018-09-15 01:53:19 +00:00
|
|
|
kfree(vaddr_out);
|
2018-09-06 05:18:26 +00:00
|
|
|
return crc;
|
2018-08-02 01:10:26 +00:00
|
|
|
}
|
|
|
|
|
2018-09-06 05:18:26 +00:00
|
|
|
memcpy(vaddr_out, vkms_obj->vaddr, vkms_obj->gem.size);
|
2018-08-03 20:11:42 +00:00
|
|
|
mutex_unlock(&vkms_obj->pages_lock);
|
2018-09-06 05:18:26 +00:00
|
|
|
|
|
|
|
if (cursor_crc)
|
|
|
|
compose_cursor(cursor_crc, primary_crc, vaddr_out);
|
|
|
|
|
|
|
|
crc = compute_crc(vaddr_out, primary_crc);
|
|
|
|
|
|
|
|
kfree(vaddr_out);
|
|
|
|
|
2018-08-02 01:10:26 +00:00
|
|
|
return crc;
|
|
|
|
}
|
|
|
|
|
2018-09-03 21:18:17 +00:00
|
|
|
/**
|
|
|
|
* vkms_crc_work_handle - ordered work_struct to compute CRC
|
|
|
|
*
|
|
|
|
* @work: work_struct
|
|
|
|
*
|
|
|
|
* Work handler for computing CRCs. work_struct scheduled in
|
|
|
|
* an ordered workqueue that's periodically scheduled to run by
|
|
|
|
* _vblank_handle() and flushed at vkms_atomic_crtc_destroy_state().
|
|
|
|
*/
|
2018-08-02 01:10:26 +00:00
|
|
|
void vkms_crc_work_handle(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct vkms_crtc_state *crtc_state = container_of(work,
|
|
|
|
struct vkms_crtc_state,
|
|
|
|
crc_work);
|
|
|
|
struct drm_crtc *crtc = crtc_state->base.crtc;
|
|
|
|
struct vkms_output *out = drm_crtc_to_vkms_output(crtc);
|
|
|
|
struct vkms_device *vdev = container_of(out, struct vkms_device,
|
|
|
|
output);
|
|
|
|
struct vkms_crc_data *primary_crc = NULL;
|
2018-09-06 05:18:26 +00:00
|
|
|
struct vkms_crc_data *cursor_crc = NULL;
|
2018-08-02 01:10:26 +00:00
|
|
|
struct drm_plane *plane;
|
|
|
|
u32 crc32 = 0;
|
2018-09-03 21:18:17 +00:00
|
|
|
u64 frame_start, frame_end;
|
drm/vkms: Fix crc worker races
The issue we have is that the crc worker might fall behind. We've
tried to handle this by tracking both the earliest frame for which it
still needs to compute a crc, and the last one. Plus when the
crtc_state changes, we have a new work item, which are all run in
order due to the ordered workqueue we allocate for each vkms crtc.
Trouble is there's been a few small issues in the current code:
- we need to capture frame_end in the vblank hrtimer, not in the
worker. The worker might run much later, and then we generate a lot
of crc for which there's already a different worker queued up.
- frame number might be 0, so create a new crc_pending boolean to
track this without confusion.
- we need to atomically grab frame_start/end and clear it, so do that
all in one go. This is not going to create a new race, because if we
race with the hrtimer then our work will be re-run.
- only race that can happen is the following:
1. worker starts
2. hrtimer runs and updates frame_end
3. worker grabs frame_start/end, already reading the new frame_end,
and clears crc_pending
4. hrtimer calls queue_work()
5. worker completes
6. worker gets re-run, crc_pending is false
Explain this case a bit better by rewording the comment.
v2: Demote warning level output to debug when we fail to requeue, this
is expected under high load when the crc worker can't quite keep up.
Cc: Shayenne Moura <shayenneluzmoura@gmail.com>
Cc: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Cc: Haneen Mohammed <hamohammed.sa@gmail.com>
Cc: Daniel Vetter <daniel@ffwll.ch>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Reviewed-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Tested-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Signed-off-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20190606222751.32567-2-daniel.vetter@ffwll.ch
2019-06-06 22:27:42 +00:00
|
|
|
bool crc_pending;
|
2018-09-03 21:18:17 +00:00
|
|
|
|
2019-06-06 22:27:44 +00:00
|
|
|
spin_lock_irq(&out->crc_lock);
|
2018-09-03 21:18:17 +00:00
|
|
|
frame_start = crtc_state->frame_start;
|
|
|
|
frame_end = crtc_state->frame_end;
|
drm/vkms: Fix crc worker races
The issue we have is that the crc worker might fall behind. We've
tried to handle this by tracking both the earliest frame for which it
still needs to compute a crc, and the last one. Plus when the
crtc_state changes, we have a new work item, which are all run in
order due to the ordered workqueue we allocate for each vkms crtc.
Trouble is there's been a few small issues in the current code:
- we need to capture frame_end in the vblank hrtimer, not in the
worker. The worker might run much later, and then we generate a lot
of crc for which there's already a different worker queued up.
- frame number might be 0, so create a new crc_pending boolean to
track this without confusion.
- we need to atomically grab frame_start/end and clear it, so do that
all in one go. This is not going to create a new race, because if we
race with the hrtimer then our work will be re-run.
- only race that can happen is the following:
1. worker starts
2. hrtimer runs and updates frame_end
3. worker grabs frame_start/end, already reading the new frame_end,
and clears crc_pending
4. hrtimer calls queue_work()
5. worker completes
6. worker gets re-run, crc_pending is false
Explain this case a bit better by rewording the comment.
v2: Demote warning level output to debug when we fail to requeue, this
is expected under high load when the crc worker can't quite keep up.
Cc: Shayenne Moura <shayenneluzmoura@gmail.com>
Cc: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Cc: Haneen Mohammed <hamohammed.sa@gmail.com>
Cc: Daniel Vetter <daniel@ffwll.ch>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Reviewed-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Tested-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Signed-off-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20190606222751.32567-2-daniel.vetter@ffwll.ch
2019-06-06 22:27:42 +00:00
|
|
|
crc_pending = crtc_state->crc_pending;
|
|
|
|
crtc_state->frame_start = 0;
|
|
|
|
crtc_state->frame_end = 0;
|
|
|
|
crtc_state->crc_pending = false;
|
2019-06-06 22:27:44 +00:00
|
|
|
spin_unlock_irq(&out->crc_lock);
|
2018-09-03 21:18:17 +00:00
|
|
|
|
drm/vkms: Fix crc worker races
The issue we have is that the crc worker might fall behind. We've
tried to handle this by tracking both the earliest frame for which it
still needs to compute a crc, and the last one. Plus when the
crtc_state changes, we have a new work item, which are all run in
order due to the ordered workqueue we allocate for each vkms crtc.
Trouble is there's been a few small issues in the current code:
- we need to capture frame_end in the vblank hrtimer, not in the
worker. The worker might run much later, and then we generate a lot
of crc for which there's already a different worker queued up.
- frame number might be 0, so create a new crc_pending boolean to
track this without confusion.
- we need to atomically grab frame_start/end and clear it, so do that
all in one go. This is not going to create a new race, because if we
race with the hrtimer then our work will be re-run.
- only race that can happen is the following:
1. worker starts
2. hrtimer runs and updates frame_end
3. worker grabs frame_start/end, already reading the new frame_end,
and clears crc_pending
4. hrtimer calls queue_work()
5. worker completes
6. worker gets re-run, crc_pending is false
Explain this case a bit better by rewording the comment.
v2: Demote warning level output to debug when we fail to requeue, this
is expected under high load when the crc worker can't quite keep up.
Cc: Shayenne Moura <shayenneluzmoura@gmail.com>
Cc: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Cc: Haneen Mohammed <hamohammed.sa@gmail.com>
Cc: Daniel Vetter <daniel@ffwll.ch>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Reviewed-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Tested-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Signed-off-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20190606222751.32567-2-daniel.vetter@ffwll.ch
2019-06-06 22:27:42 +00:00
|
|
|
/*
|
|
|
|
* We raced with the vblank hrtimer and previous work already computed
|
|
|
|
* the crc, nothing to do.
|
|
|
|
*/
|
|
|
|
if (!crc_pending)
|
|
|
|
return;
|
2018-08-02 01:10:26 +00:00
|
|
|
|
|
|
|
drm_for_each_plane(plane, &vdev->drm) {
|
|
|
|
struct vkms_plane_state *vplane_state;
|
|
|
|
struct vkms_crc_data *crc_data;
|
|
|
|
|
|
|
|
vplane_state = to_vkms_plane_state(plane->state);
|
|
|
|
crc_data = vplane_state->crc_data;
|
|
|
|
|
|
|
|
if (drm_framebuffer_read_refcount(&crc_data->fb) == 0)
|
|
|
|
continue;
|
|
|
|
|
2018-09-06 05:18:26 +00:00
|
|
|
if (plane->type == DRM_PLANE_TYPE_PRIMARY)
|
2018-08-02 01:10:26 +00:00
|
|
|
primary_crc = crc_data;
|
2018-09-06 05:18:26 +00:00
|
|
|
else
|
|
|
|
cursor_crc = crc_data;
|
2018-08-02 01:10:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (primary_crc)
|
2018-09-06 05:18:26 +00:00
|
|
|
crc32 = _vkms_get_crc(primary_crc, cursor_crc);
|
2018-08-02 01:10:26 +00:00
|
|
|
|
drm/vkms: Fix crc worker races
The issue we have is that the crc worker might fall behind. We've
tried to handle this by tracking both the earliest frame for which it
still needs to compute a crc, and the last one. Plus when the
crtc_state changes, we have a new work item, which are all run in
order due to the ordered workqueue we allocate for each vkms crtc.
Trouble is there's been a few small issues in the current code:
- we need to capture frame_end in the vblank hrtimer, not in the
worker. The worker might run much later, and then we generate a lot
of crc for which there's already a different worker queued up.
- frame number might be 0, so create a new crc_pending boolean to
track this without confusion.
- we need to atomically grab frame_start/end and clear it, so do that
all in one go. This is not going to create a new race, because if we
race with the hrtimer then our work will be re-run.
- only race that can happen is the following:
1. worker starts
2. hrtimer runs and updates frame_end
3. worker grabs frame_start/end, already reading the new frame_end,
and clears crc_pending
4. hrtimer calls queue_work()
5. worker completes
6. worker gets re-run, crc_pending is false
Explain this case a bit better by rewording the comment.
v2: Demote warning level output to debug when we fail to requeue, this
is expected under high load when the crc worker can't quite keep up.
Cc: Shayenne Moura <shayenneluzmoura@gmail.com>
Cc: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Cc: Haneen Mohammed <hamohammed.sa@gmail.com>
Cc: Daniel Vetter <daniel@ffwll.ch>
Signed-off-by: Daniel Vetter <daniel.vetter@intel.com>
Reviewed-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Tested-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Signed-off-by: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20190606222751.32567-2-daniel.vetter@ffwll.ch
2019-06-06 22:27:42 +00:00
|
|
|
/*
|
|
|
|
* The worker can fall behind the vblank hrtimer, make sure we catch up.
|
2018-09-03 21:18:17 +00:00
|
|
|
*/
|
|
|
|
while (frame_start <= frame_end)
|
|
|
|
drm_crtc_add_crc_entry(crtc, true, frame_start++, &crc32);
|
2018-08-02 01:10:26 +00:00
|
|
|
}
|
|
|
|
|
2019-06-13 12:18:02 +00:00
|
|
|
static const char * const pipe_crc_sources[] = {"auto"};
|
|
|
|
|
|
|
|
const char *const *vkms_get_crc_sources(struct drm_crtc *crtc,
|
|
|
|
size_t *count)
|
|
|
|
{
|
|
|
|
*count = ARRAY_SIZE(pipe_crc_sources);
|
|
|
|
return pipe_crc_sources;
|
|
|
|
}
|
|
|
|
|
2018-08-21 08:38:55 +00:00
|
|
|
static int vkms_crc_parse_source(const char *src_name, bool *enabled)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!src_name) {
|
|
|
|
*enabled = false;
|
|
|
|
} else if (strcmp(src_name, "auto") == 0) {
|
|
|
|
*enabled = true;
|
|
|
|
} else {
|
|
|
|
*enabled = false;
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int vkms_verify_crc_source(struct drm_crtc *crtc, const char *src_name,
|
|
|
|
size_t *values_cnt)
|
|
|
|
{
|
|
|
|
bool enabled;
|
|
|
|
|
|
|
|
if (vkms_crc_parse_source(src_name, &enabled) < 0) {
|
|
|
|
DRM_DEBUG_DRIVER("unknown source %s\n", src_name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
*values_cnt = 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-08-21 08:38:56 +00:00
|
|
|
int vkms_set_crc_source(struct drm_crtc *crtc, const char *src_name)
|
2018-08-02 01:10:26 +00:00
|
|
|
{
|
|
|
|
struct vkms_output *out = drm_crtc_to_vkms_output(crtc);
|
|
|
|
bool enabled = false;
|
|
|
|
int ret = 0;
|
|
|
|
|
2018-08-21 08:38:55 +00:00
|
|
|
ret = vkms_crc_parse_source(src_name, &enabled);
|
2018-08-02 01:10:26 +00:00
|
|
|
|
2019-06-06 22:27:43 +00:00
|
|
|
spin_lock_irq(&out->lock);
|
2018-08-02 01:10:26 +00:00
|
|
|
out->crc_enabled = enabled;
|
2019-06-06 22:27:43 +00:00
|
|
|
spin_unlock_irq(&out->lock);
|
2018-08-02 01:10:26 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|