2019-02-06 14:01:16 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
|
|
|
|
2018-08-02 01:10:26 +00:00
|
|
|
#include <linux/crc32.h>
|
2019-06-30 06:19:01 +00:00
|
|
|
|
2018-09-06 05:18:26 +00:00
|
|
|
#include <drm/drm_atomic.h>
|
|
|
|
#include <drm/drm_atomic_helper.h>
|
2021-04-24 08:25:31 +00:00
|
|
|
#include <drm/drm_fourcc.h>
|
2018-08-02 01:10:26 +00:00
|
|
|
#include <drm/drm_gem_framebuffer_helper.h>
|
2019-06-30 06:19:01 +00:00
|
|
|
#include <drm/drm_vblank.h>
|
2022-09-05 19:08:08 +00:00
|
|
|
#include <linux/minmax.h>
|
2019-06-30 06:19:01 +00:00
|
|
|
|
|
|
|
#include "vkms_drv.h"
|
2018-08-02 01:10:26 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
static u16 pre_mul_blend_channel(u16 src, u16 dst, u16 alpha)
|
2020-08-30 14:19:59 +00:00
|
|
|
{
|
2022-09-05 19:08:08 +00:00
|
|
|
u32 new_color;
|
2020-08-30 14:19:59 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
new_color = (src * 0xffff + dst * (0xffff - alpha));
|
2020-08-30 14:19:59 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
return DIV_ROUND_CLOSEST(new_color, 0xffff);
|
2020-08-30 14:19:59 +00:00
|
|
|
}
|
|
|
|
|
2018-09-06 05:18:26 +00:00
|
|
|
/**
|
2022-09-05 19:08:08 +00:00
|
|
|
* 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
|
2018-09-06 05:18:26 +00:00
|
|
|
*
|
2022-09-05 19:08:08 +00:00
|
|
|
* 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.
|
2018-09-06 05:18:26 +00:00
|
|
|
*
|
2022-09-05 19:08:08 +00:00
|
|
|
* 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.
|
2018-09-06 05:18:26 +00:00
|
|
|
*/
|
2022-09-05 19:08:08 +00:00
|
|
|
static void pre_mul_alpha_blend(struct vkms_frame_info *frame_info,
|
|
|
|
struct line_buffer *stage_buffer,
|
|
|
|
struct line_buffer *output_buffer)
|
2018-09-06 05:18:26 +00:00
|
|
|
{
|
2022-09-05 19:08:08 +00:00
|
|
|
int x_dst = frame_info->dst.x1;
|
|
|
|
struct pixel_argb_u16 *out = output_buffer->pixels + x_dst;
|
|
|
|
struct pixel_argb_u16 *in = stage_buffer->pixels;
|
|
|
|
int x_limit = min_t(size_t, drm_rect_width(&frame_info->dst),
|
|
|
|
stage_buffer->n_pixels);
|
|
|
|
|
|
|
|
for (int 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);
|
2018-09-06 05:18:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
static bool check_y_limit(struct vkms_frame_info *frame_info, int y)
|
2020-08-25 11:45:32 +00:00
|
|
|
{
|
2022-09-05 19:08:08 +00:00
|
|
|
if (y >= frame_info->dst.y1 && y < frame_info->dst.y2)
|
|
|
|
return true;
|
2020-08-25 11:45:32 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
return false;
|
2020-08-25 11:45:32 +00:00
|
|
|
}
|
|
|
|
|
2022-09-05 19:08:09 +00:00
|
|
|
static void fill_background(const struct pixel_argb_u16 *background_color,
|
|
|
|
struct line_buffer *output_buffer)
|
|
|
|
{
|
|
|
|
for (size_t i = 0; i < output_buffer->n_pixels; i++)
|
|
|
|
output_buffer->pixels[i] = *background_color;
|
|
|
|
}
|
|
|
|
|
2021-04-24 08:25:31 +00:00
|
|
|
/**
|
2022-09-05 19:08:08 +00:00
|
|
|
* @wb_frame_info: The writeback frame buffer metadata
|
|
|
|
* @crtc_state: The crtc state
|
|
|
|
* @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 plane being blend to the output
|
2021-04-24 08:25:31 +00:00
|
|
|
*
|
2022-09-05 19:08:08 +00:00
|
|
|
* 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.
|
2021-04-24 08:25:31 +00:00
|
|
|
*/
|
2022-09-05 19:08:08 +00:00
|
|
|
static void blend(struct vkms_writeback_job *wb,
|
|
|
|
struct vkms_crtc_state *crtc_state,
|
|
|
|
u32 *crc32, struct line_buffer *stage_buffer,
|
|
|
|
struct line_buffer *output_buffer, size_t row_size)
|
2020-08-25 11:45:32 +00:00
|
|
|
{
|
2022-09-05 19:08:08 +00:00
|
|
|
struct vkms_plane_state **plane = crtc_state->active_planes;
|
|
|
|
u32 n_active_planes = crtc_state->num_active_planes;
|
|
|
|
|
2022-09-05 19:08:09 +00:00
|
|
|
const struct pixel_argb_u16 background_color = { .a = 0xffff };
|
2022-09-05 19:08:08 +00:00
|
|
|
|
2022-09-05 19:08:09 +00:00
|
|
|
size_t crtc_y_limit = crtc_state->base.crtc->mode.vdisplay;
|
2022-09-05 19:08:08 +00:00
|
|
|
|
2022-09-05 19:08:09 +00:00
|
|
|
for (size_t y = 0; y < crtc_y_limit; y++) {
|
|
|
|
fill_background(&background_color, output_buffer);
|
|
|
|
|
|
|
|
/* The active planes are composed associatively in z-order. */
|
|
|
|
for (size_t i = 0; i < n_active_planes; i++) {
|
2022-09-05 19:08:08 +00:00
|
|
|
if (!check_y_limit(plane[i]->frame_info, y))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
plane[i]->plane_read(stage_buffer, plane[i]->frame_info, y);
|
|
|
|
pre_mul_alpha_blend(plane[i]->frame_info, stage_buffer,
|
|
|
|
output_buffer);
|
|
|
|
}
|
2020-08-25 11:45:32 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
*crc32 = crc32_le(*crc32, (void *)output_buffer->pixels, row_size);
|
2021-04-24 08:25:31 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
if (wb)
|
|
|
|
wb->wb_write(&wb->wb_frame_info, output_buffer, y);
|
2018-09-06 05:18:26 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
static int check_format_funcs(struct vkms_crtc_state *crtc_state,
|
|
|
|
struct vkms_writeback_job *active_wb)
|
2018-09-06 05:18:26 +00:00
|
|
|
{
|
2022-09-05 19:08:08 +00:00
|
|
|
struct vkms_plane_state **planes = crtc_state->active_planes;
|
|
|
|
u32 n_active_planes = crtc_state->num_active_planes;
|
2018-09-06 05:18:26 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
for (size_t i = 0; i < n_active_planes; i++)
|
|
|
|
if (!planes[i]->plane_read)
|
|
|
|
return -1;
|
2021-07-05 07:46:33 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
if (active_wb && !active_wb->wb_write)
|
|
|
|
return -1;
|
2021-04-24 08:25:31 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
return 0;
|
2018-09-06 05:18:26 +00:00
|
|
|
}
|
|
|
|
|
2022-09-05 19:08:09 +00:00
|
|
|
static int check_iosys_map(struct vkms_crtc_state *crtc_state)
|
|
|
|
{
|
|
|
|
struct vkms_plane_state **plane_state = crtc_state->active_planes;
|
|
|
|
u32 n_active_planes = crtc_state->num_active_planes;
|
|
|
|
|
|
|
|
for (size_t i = 0; i < n_active_planes; i++)
|
|
|
|
if (iosys_map_is_null(&plane_state[i]->frame_info->map[0]))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
static int compose_active_planes(struct vkms_writeback_job *active_wb,
|
|
|
|
struct vkms_crtc_state *crtc_state,
|
|
|
|
u32 *crc32)
|
2018-09-06 05:18:26 +00:00
|
|
|
{
|
2022-09-05 19:08:08 +00:00
|
|
|
size_t line_width, pixel_size = sizeof(struct pixel_argb_u16);
|
|
|
|
struct line_buffer output_buffer, stage_buffer;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This check exists so we can call `crc32_le` for the entire line
|
|
|
|
* instead doing it for each channel of each pixel in case
|
|
|
|
* `struct `pixel_argb_u16` had any gap added by the compiler
|
|
|
|
* between the struct fields.
|
|
|
|
*/
|
|
|
|
static_assert(sizeof(struct pixel_argb_u16) == 8);
|
|
|
|
|
2022-09-05 19:08:09 +00:00
|
|
|
if (WARN_ON(check_iosys_map(crtc_state)))
|
2020-08-30 14:19:58 +00:00
|
|
|
return -EINVAL;
|
2018-08-02 01:10:26 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
if (WARN_ON(check_format_funcs(crtc_state, active_wb)))
|
|
|
|
return -EINVAL;
|
2021-07-05 07:46:33 +00:00
|
|
|
|
2022-09-05 19:08:09 +00:00
|
|
|
line_width = crtc_state->base.crtc->mode.hdisplay;
|
2022-09-05 19:08:08 +00:00
|
|
|
stage_buffer.n_pixels = line_width;
|
|
|
|
output_buffer.n_pixels = line_width;
|
2018-09-06 05:18:26 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
stage_buffer.pixels = kvmalloc(line_width * pixel_size, GFP_KERNEL);
|
|
|
|
if (!stage_buffer.pixels) {
|
|
|
|
DRM_ERROR("Cannot allocate memory for the output line buffer");
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
2018-09-06 05:18:26 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
output_buffer.pixels = kvmalloc(line_width * pixel_size, GFP_KERNEL);
|
|
|
|
if (!output_buffer.pixels) {
|
|
|
|
DRM_ERROR("Cannot allocate memory for intermediate line buffer");
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto free_stage_buffer;
|
|
|
|
}
|
|
|
|
|
|
|
|
blend(active_wb, crtc_state, crc32, &stage_buffer,
|
|
|
|
&output_buffer, line_width * pixel_size);
|
|
|
|
|
|
|
|
kvfree(output_buffer.pixels);
|
|
|
|
free_stage_buffer:
|
|
|
|
kvfree(stage_buffer.pixels);
|
|
|
|
|
|
|
|
return ret;
|
2018-08-02 01:10:26 +00:00
|
|
|
}
|
|
|
|
|
2018-09-03 21:18:17 +00:00
|
|
|
/**
|
2019-06-26 01:37:05 +00:00
|
|
|
* vkms_composer_worker - ordered work_struct to compute CRC
|
2018-09-03 21:18:17 +00:00
|
|
|
*
|
|
|
|
* @work: work_struct
|
|
|
|
*
|
2019-06-26 01:37:05 +00:00
|
|
|
* Work handler for composing and computing CRCs. work_struct scheduled in
|
2018-09-03 21:18:17 +00:00
|
|
|
* an ordered workqueue that's periodically scheduled to run by
|
2022-05-21 19:13:42 +00:00
|
|
|
* vkms_vblank_simulate() and flushed at vkms_atomic_commit_tail().
|
2018-09-03 21:18:17 +00:00
|
|
|
*/
|
2019-06-26 01:37:05 +00:00
|
|
|
void vkms_composer_worker(struct work_struct *work)
|
2018-08-02 01:10:26 +00:00
|
|
|
{
|
|
|
|
struct vkms_crtc_state *crtc_state = container_of(work,
|
|
|
|
struct vkms_crtc_state,
|
2019-06-26 01:37:05 +00:00
|
|
|
composer_work);
|
2018-08-02 01:10:26 +00:00
|
|
|
struct drm_crtc *crtc = crtc_state->base.crtc;
|
2022-09-05 19:08:08 +00:00
|
|
|
struct vkms_writeback_job *active_wb = crtc_state->active_writeback;
|
2018-08-02 01:10:26 +00:00
|
|
|
struct vkms_output *out = drm_crtc_to_vkms_output(crtc);
|
2020-08-30 14:20:00 +00:00
|
|
|
bool crc_pending, wb_pending;
|
2018-09-03 21:18:17 +00:00
|
|
|
u64 frame_start, frame_end;
|
2022-09-05 19:08:08 +00:00
|
|
|
u32 crc32 = 0;
|
2020-08-30 14:19:58 +00:00
|
|
|
int ret;
|
2018-09-03 21:18:17 +00:00
|
|
|
|
2019-06-26 01:37:05 +00:00
|
|
|
spin_lock_irq(&out->composer_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;
|
2020-08-30 14:20:00 +00:00
|
|
|
wb_pending = crtc_state->wb_pending;
|
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
|
|
|
crtc_state->frame_start = 0;
|
|
|
|
crtc_state->frame_end = 0;
|
|
|
|
crtc_state->crc_pending = false;
|
2019-06-26 01:37:05 +00:00
|
|
|
spin_unlock_irq(&out->composer_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
|
|
|
|
2020-08-30 14:20:00 +00:00
|
|
|
if (wb_pending)
|
2022-09-05 19:08:08 +00:00
|
|
|
ret = compose_active_planes(active_wb, crtc_state, &crc32);
|
|
|
|
else
|
|
|
|
ret = compose_active_planes(NULL, crtc_state, &crc32);
|
2020-08-30 14:20:00 +00:00
|
|
|
|
2022-09-05 19:08:08 +00:00
|
|
|
if (ret)
|
2020-08-30 14:19:58 +00:00
|
|
|
return;
|
2018-08-02 01:10:26 +00:00
|
|
|
|
2020-08-30 14:20:00 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2020-08-30 14:20:00 +00:00
|
|
|
void vkms_set_composer(struct vkms_output *out, bool enabled)
|
drm/vkms: guarantee vblank when capturing crc
VKMS needs vblank interrupts enabled to capture CRC. When vblank is
disabled, tests like kms_cursor_crc and kms_pipe_crc_basic getting stuck
waiting for a capture that will not occur until vkms wakes up. This patch
adds a helper to set composer and ensure that vblank remains enabled as
long as the CRC capture is needed.
It clears the execution of the following kms_cursor_crc subtests:
1. pipe-A-cursor-[size,alpha-opaque, NxN-(on-screen, off-screen, sliding,
random, fast-moving])] - successful when running individually.
2. pipe-A-cursor-dpms passes again
3. pipe-A-cursor-suspend also passes
The issue was initially tracked in the sequential execution of IGT
kms_cursor_crc subtests: when running the test sequence or one of its
subtests twice, the odd execs complete and the pairs get stuck in an
endless wait. In the IGT code, calling a wait_for_vblank on preparing for
CRC capture prevented the busy-wait. But the problem persisted in the
pipe-A-cursor-dpms and -suspend subtests.
Checking the history, the pipe-A-cursor-dpms subtest was successful when,
in vkms_atomic_commit_tail, instead of using the flip_done op, it used
wait_for_vblanks. Another way to prevent blocking was wait_one_vblank when
enabling crtc. However, in both cases, pipe-A-cursor-suspend persisted
blocking in the 2nd start of CRC capture, which may indicate that
something got stuck in the step of CRC setup. Indeed, wait_one_vblank in
the crc setup was able to sync things and free all kms_cursor_crc
subtests. Besides, other alternatives to force enabling vblanks or prevent
disabling them such as calling drm_crtc_put_vblank or modeset_enables
before commit_planes + offdelay = 0, also unlock all subtests executions.
Finally, due to vkms's dependence on vblank interruptions to perform
tasks, this patch uses refcount to ensure that vblanks happen when
enabling composer and while crc capture is needed.
Cc: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Cc: Haneen Mohammed <hamohammed.sa@gmail.com>
v2:
- extract a vkms_set_composer helper
- fix vblank refcounting for the disabling case
v3:
- make the vkms_set_composer helper static
- review the credit tags
Co-debugged-by: Sidong Yang <realwakka@gmail.com>
Signed-off-by: Sidong Yang <realwakka@gmail.com>
Signed-off-by: Melissa Wen <melissa.srw@gmail.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
[danvet: add changelog back in]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: https://patchwork.freedesktop.org/patch/msgid/20200808120900.pudwwrfz44g3rqx7@smtp.gmail.com
2020-08-08 12:09:00 +00:00
|
|
|
{
|
|
|
|
bool old_enabled;
|
|
|
|
|
|
|
|
if (enabled)
|
|
|
|
drm_crtc_vblank_get(&out->crtc);
|
|
|
|
|
|
|
|
spin_lock_irq(&out->lock);
|
|
|
|
old_enabled = out->composer_enabled;
|
|
|
|
out->composer_enabled = enabled;
|
|
|
|
spin_unlock_irq(&out->lock);
|
|
|
|
|
|
|
|
if (old_enabled)
|
|
|
|
drm_crtc_vblank_put(&out->crtc);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
drm/vkms: guarantee vblank when capturing crc
VKMS needs vblank interrupts enabled to capture CRC. When vblank is
disabled, tests like kms_cursor_crc and kms_pipe_crc_basic getting stuck
waiting for a capture that will not occur until vkms wakes up. This patch
adds a helper to set composer and ensure that vblank remains enabled as
long as the CRC capture is needed.
It clears the execution of the following kms_cursor_crc subtests:
1. pipe-A-cursor-[size,alpha-opaque, NxN-(on-screen, off-screen, sliding,
random, fast-moving])] - successful when running individually.
2. pipe-A-cursor-dpms passes again
3. pipe-A-cursor-suspend also passes
The issue was initially tracked in the sequential execution of IGT
kms_cursor_crc subtests: when running the test sequence or one of its
subtests twice, the odd execs complete and the pairs get stuck in an
endless wait. In the IGT code, calling a wait_for_vblank on preparing for
CRC capture prevented the busy-wait. But the problem persisted in the
pipe-A-cursor-dpms and -suspend subtests.
Checking the history, the pipe-A-cursor-dpms subtest was successful when,
in vkms_atomic_commit_tail, instead of using the flip_done op, it used
wait_for_vblanks. Another way to prevent blocking was wait_one_vblank when
enabling crtc. However, in both cases, pipe-A-cursor-suspend persisted
blocking in the 2nd start of CRC capture, which may indicate that
something got stuck in the step of CRC setup. Indeed, wait_one_vblank in
the crc setup was able to sync things and free all kms_cursor_crc
subtests. Besides, other alternatives to force enabling vblanks or prevent
disabling them such as calling drm_crtc_put_vblank or modeset_enables
before commit_planes + offdelay = 0, also unlock all subtests executions.
Finally, due to vkms's dependence on vblank interruptions to perform
tasks, this patch uses refcount to ensure that vblanks happen when
enabling composer and while crc capture is needed.
Cc: Rodrigo Siqueira <rodrigosiqueiramelo@gmail.com>
Cc: Haneen Mohammed <hamohammed.sa@gmail.com>
v2:
- extract a vkms_set_composer helper
- fix vblank refcounting for the disabling case
v3:
- make the vkms_set_composer helper static
- review the credit tags
Co-debugged-by: Sidong Yang <realwakka@gmail.com>
Signed-off-by: Sidong Yang <realwakka@gmail.com>
Signed-off-by: Melissa Wen <melissa.srw@gmail.com>
Reviewed-by: Daniel Vetter <daniel.vetter@ffwll.ch>
[danvet: add changelog back in]
Signed-off-by: Daniel Vetter <daniel.vetter@ffwll.ch>
Link: https://patchwork.freedesktop.org/patch/msgid/20200808120900.pudwwrfz44g3rqx7@smtp.gmail.com
2020-08-08 12:09:00 +00:00
|
|
|
vkms_set_composer(out, enabled);
|
2018-08-02 01:10:26 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|