Op 20-10-17 om 12:16 schreef Mika Kahola: > On Fri, 2017-10-20 at 12:08 +0200, Maarten Lankhorst wrote: >> Op 20-10-17 om 12:02 schreef Mika Kahola: >>> On Thu, 2017-10-12 at 17:33 +0200, Maarten Lankhorst wrote: >>>> Now that we can set individual properties through the igt_kms >>>> api, >>>> we no longer need to duplicate functionality from igt_kms. Set >>>> invalid >>>> properties directly, and rewrite kms_atomic.c to use igt_display. >>>> This will allow us to remove a lot of code in kms_atomic.c, >>>> and benefit from how igt_kms can set up a valid configuration, >>>> instead of having to inherit it from fbcon. >>>> >>>> Changes since v1: >>>> - Fix test failure when atomic_invalid_params is run standalone. >>>> >>>> Signed-off-by: Maarten Lankhorst <[email protected] >>>> om> >>>> Cc: Daniel Stone <[email protected]> >>>> --- >>>> tests/kms_atomic.c | 1668 ++++++++++++++++-------------------- >>>> ---- >>>> ------------ >>>> 1 file changed, 512 insertions(+), 1156 deletions(-) >>>> >>>> diff --git a/tests/kms_atomic.c b/tests/kms_atomic.c >>>> index 042a7c263aab..e0fc324eab61 100644 >>>> --- a/tests/kms_atomic.c >>>> +++ b/tests/kms_atomic.c >>>> @@ -46,10 +46,6 @@ >>>> #include "igt_aux.h" >>>> #include "sw_sync.h" >>>> >>>> -#ifndef DRM_CLIENT_CAP_ATOMIC >>>> -#define DRM_CLIENT_CAP_ATOMIC 3 >>>> -#endif >>>> - >>>> #ifndef DRM_CAP_CURSOR_WIDTH >>>> #define DRM_CAP_CURSOR_WIDTH 0x8 >>>> #endif >>>> @@ -58,23 +54,6 @@ >>>> #define DRM_CAP_CURSOR_HEIGHT 0x9 >>>> #endif >>>> >>>> -#ifndef DRM_MODE_ATOMIC_TEST_ONLY >>>> -#define DRM_MODE_ATOMIC_TEST_ONLY 0x0100 >>>> -#define DRM_MODE_ATOMIC_NONBLOCK 0x0200 >>>> -#define DRM_MODE_ATOMIC_ALLOW_MODESET 0x0400 >>>> - >>>> -struct drm_mode_atomic { >>>> - __u32 flags; >>>> - __u32 count_objs; >>>> - __u64 objs_ptr; >>>> - __u64 count_props_ptr; >>>> - __u64 props_ptr; >>>> - __u64 prop_values_ptr; >>>> - __u64 reserved; >>>> - __u64 user_data; >>>> -}; >>>> -#endif >>>> - >>>> IGT_TEST_DESCRIPTION("Test atomic modesetting API"); >>>> >>>> enum kms_atomic_check_relax { >>>> @@ -83,1259 +62,652 @@ enum kms_atomic_check_relax { >>>> PLANE_RELAX_FB = (1 << 1) >>>> }; >>>> >>>> -/** >>>> - * KMS plane type enum >>>> - * >>>> - * KMS plane types are represented by enums, which do not have >>>> stable numeric >>>> - * values, but must be looked up by their string value each >>>> time. >>>> - * >>>> - * To make the code more simple, we define a plane_type enum >>>> which >>>> maps to >>>> - * each KMS enum value. These values must be looked up through >>>> the >>>> map, and >>>> - * cannot be passed directly to KMS functions. >>>> - */ >>>> -enum plane_type { >>>> - PLANE_TYPE_PRIMARY = 0, >>>> - PLANE_TYPE_OVERLAY, >>>> - PLANE_TYPE_CURSOR, >>>> - NUM_PLANE_TYPE_PROPS >>>> -}; >>>> - >>>> -static const char *plane_type_prop_names[NUM_PLANE_TYPE_PROPS] = >>>> { >>>> - "Primary", >>>> - "Overlay", >>>> - "Cursor" >>>> -}; >>>> - >>>> -struct kms_atomic_blob { >>>> - uint32_t id; /* 0 if not already allocated */ >>>> - size_t len; >>>> - void *data; >>>> -}; >>>> - >>>> -struct kms_atomic_connector_state { >>>> - struct kms_atomic_state *state; >>>> - uint32_t obj; >>>> - uint32_t crtc_id; >>>> -}; >>>> - >>>> -struct kms_atomic_plane_state { >>>> - struct kms_atomic_state *state; >>>> - uint32_t obj; >>>> - enum plane_type type; >>>> - uint32_t crtc_mask; >>>> - uint32_t crtc_id; /* 0 to disable */ >>>> - uint32_t fb_id; /* 0 to disable */ >>>> - uint32_t src_x, src_y, src_w, src_h; /* 16.16 fixed- >>>> point */ >>>> - uint32_t crtc_x, crtc_y, crtc_w, crtc_h; /* normal >>>> integers >>>> */ >>>> - int32_t fence_fd; >>>> -}; >>>> - >>>> -struct kms_atomic_crtc_state { >>>> - struct kms_atomic_state *state; >>>> - uint32_t obj; >>>> - int idx; >>>> - bool active; >>>> - int32_t *out_fence_ptr; >>>> - struct kms_atomic_blob mode; >>>> -}; >>>> - >>>> -struct kms_atomic_state { >>>> - struct kms_atomic_connector_state *connectors; >>>> - int num_connectors; >>>> - struct kms_atomic_crtc_state *crtcs; >>>> - int num_crtcs; >>>> - struct kms_atomic_plane_state *planes; >>>> - int num_planes; >>>> - struct kms_atomic_desc *desc; >>>> -}; >>>> - >>>> -struct kms_atomic_desc { >>>> - int fd; >>>> - uint32_t props_connector[IGT_NUM_CONNECTOR_PROPS]; >>>> - uint32_t props_crtc[IGT_NUM_CRTC_PROPS]; >>>> - uint32_t props_plane[IGT_NUM_PLANE_PROPS]; >>>> - uint64_t props_plane_type[NUM_PLANE_TYPE_PROPS]; >>>> -}; >>>> - >>>> -static uint32_t blob_duplicate(int fd, uint32_t id_orig) >>>> +static bool plane_filter(enum igt_atomic_plane_properties prop) >>>> { >>>> - drmModePropertyBlobPtr orig = drmModeGetPropertyBlob(fd, >>>> id_orig); >>>> - uint32_t id_new; >>>> - >>>> - igt_assert(orig); >>>> - do_or_die(drmModeCreatePropertyBlob(fd, orig->data, >>>> orig- >>>>> length, >>>> - &id_new)); >>>> - drmModeFreePropertyBlob(orig); >>>> + if ((1 << prop) & IGT_PLANE_COORD_CHANGED_MASK) >>>> + return false; >>>> >>>> - return id_new; >>>> -} >>>> - >>>> -#define crtc_set_prop(req, crtc, prop, value) \ >>>> - igt_assert_lt(0, drmModeAtomicAddProperty(req, crtc- >>>>> obj, \ >>>> - crtc->state- >>>>> desc- >>>>> >>>>> props_crtc[prop], \ >>>> - value)); >>>> - >>>> -#define plane_set_prop(req, plane, prop, value) \ >>>> - igt_assert_lt(0, drmModeAtomicAddProperty(req, plane- >>>>> obj, \ >>>> - plane->state- >>>>> desc->props_plane[prop], \ >>>> - value)); >>>> - >>>> -#define do_atomic_commit(fd, req, flags) \ >>>> - do_or_die(drmModeAtomicCommit(fd, req, flags, NULL)); >>>> + if (prop == IGT_PLANE_CRTC_ID || prop == >>>> IGT_PLANE_FB_ID) >>>> + return false; >>>> >>>> -#define do_atomic_commit_err(fd, req, flags, err) { \ >>>> - igt_assert_neq(drmModeAtomicCommit(fd, req, flags, >>>> NULL), >>>> 0); \ >>>> - igt_assert_eq(errno, err); \ >>>> -} >>>> - >>>> -#define crtc_commit_atomic(crtc, plane, req, relax, flags) { \ >>>> - drmModeAtomicSetCursor(req, 0); \ >>>> - crtc_populate_req(crtc, req); \ >>>> - plane_populate_req(plane, req); \ >>>> - do_atomic_commit((crtc)->state->desc->fd, req, flags); \ >>>> - if (!(flags & DRM_MODE_ATOMIC_TEST_ONLY)) { \ >>>> - crtc_check_current_state(crtc, plane, relax); \ >>>> - plane_check_current_state(plane, relax); \ >>>> - } \ >>>> -} >>>> + if (prop == IGT_PLANE_IN_FENCE_FD) >>>> + return false; >>>> >>>> -#define crtc_commit_atomic_err(crtc, plane, crtc_old, plane_old, >>>> req, flags, relax, e) { \ >>>> - drmModeAtomicSetCursor(req, 0); \ >>>> - crtc_populate_req(crtc, req); \ >>>> - plane_populate_req(plane, req); \ >>>> - do_atomic_commit_err((crtc)->state->desc->fd, req, >>>> flags, >>>> e); \ >>>> - crtc_check_current_state(crtc_old, plane_old, relax); \ >>>> - plane_check_current_state(plane_old, relax); \ >>>> + /* Don't care about other properties */ >>>> + return true; >>>> } >>>> >>>> -#define plane_commit_atomic(plane, req, relax) { \ >>>> - drmModeAtomicSetCursor(req, 0); \ >>>> - plane_populate_req(plane, req); \ >>>> - do_atomic_commit((plane)->state->desc->fd, req, 0); \ >>>> - plane_check_current_state(plane, relax); \ >>>> -} >>>> - >>>> -#define plane_commit_atomic_err(plane, plane_old, req, relax, e) >>>> { \ >>>> - drmModeAtomicSetCursor(req, 0); \ >>>> - plane_populate_req(plane, req); \ >>>> - do_atomic_commit_err((plane)->state->desc->fd, req, 0, >>>> e); \ >>>> - plane_check_current_state(plane_old, relax); \ >>>> -} >>>> - >>>> -static void >>>> -connector_get_current_state(struct kms_atomic_connector_state >>>> *connector) >>>> -{ >>>> - drmModeObjectPropertiesPtr props; >>>> - int i; >>>> - >>>> - props = drmModeObjectGetProperties(connector->state- >>>>> desc- >>>>> >>>>> fd, >>>> - connector->obj, >>>> - DRM_MODE_OBJECT_CONNE >>>> CTOR >>>> ); >>>> - igt_assert(props); >>>> - >>>> - for (i = 0; i < props->count_props; i++) { >>>> - uint32_t *prop_ids = connector->state->desc- >>>>> props_connector; >>>> - >>>> - if (props->props[i] == >>>> prop_ids[IGT_CONNECTOR_CRTC_ID]) >>>> - connector->crtc_id = props- >>>>> prop_values[i]; >>>> - } >>>> - drmModeFreeObjectProperties(props); >>>> -} >>>> - >>>> -#if 0 >>>> -/* XXX: Checking this repeatedly actually hangs the GPU. I have >>>> literally no >>>> - * idea why. */ >>>> -static void >>>> -connector_check_current_state(struct kms_atomic_connector_state >>>> *connector) >>>> -{ >>>> - struct kms_atomic_connector_state connector_kernel; >>>> - drmModeConnectorPtr legacy; >>>> - uint32_t crtc_id; >>>> - >>>> - legacy = drmModeGetConnectorCurrent(connector->state- >>>>> desc- >>>>> >>>>> fd, >>>> - connector->obj); >>>> - igt_assert(legacy); >>>> - >>>> - if (legacy->encoder_id) { >>>> - drmModeEncoderPtr legacy_enc; >>>> - >>>> - legacy_enc = drmModeGetEncoder(connector->state- >>>>> desc->fd, >>>> - legacy- >>>>> encoder_id); >>>> - igt_assert(legacy_enc); >>>> - >>>> - crtc_id = legacy_enc->crtc_id; >>>> - drmModeFreeEncoder(legacy_enc); >>>> - } else { >>>> - crtc_id = 0; >>>> - } >>>> - >>>> - igt_assert_eq_u32(crtc_id, connector->crtc_id); >>>> - >>>> - memcpy(&connector_kernel, connector, >>>> sizeof(connector_kernel)); >>>> - connector_get_current_state(&connector_kernel); >>>> - do_or_die(memcmp(&connector_kernel, connector, >>>> - sizeof(connector_kernel))); >>>> - >>>> - drmModeFreeConnector(legacy); >>>> -} >>>> -#endif >>>> - >>>> -static struct kms_atomic_connector_state * >>>> -find_connector(struct kms_atomic_state *state, >>>> - struct kms_atomic_crtc_state *crtc) >>>> +static void plane_get_current_state(igt_plane_t *plane, uint64_t >>>> *values) >>>> { >>>> int i; >>>> >>>> - for (i = 0; i < state->num_connectors; i++) { >>>> - struct kms_atomic_connector_state *connector = >>>> - &state->connectors[i]; >>>> - >>>> - if (!connector->obj) >>>> + for (i = 0; i < IGT_NUM_PLANE_PROPS; i++) { >>>> + if (plane_filter(i)) { >>>> + values[i] = 0; >>>> continue; >>>> - if (crtc && connector->crtc_id != crtc->obj) >>>> - continue; >>>> - >>>> - return connector; >>>> - } >>>> - >>>> - return NULL; >>>> -} >>>> - >>>> -static void plane_populate_req(struct kms_atomic_plane_state >>>> *plane, >>>> - drmModeAtomicReq *req) >>>> -{ >>>> - if (plane->fence_fd) >>>> - plane_set_prop(req, plane, >>>> IGT_PLANE_IN_FENCE_FD, >>>> plane->fence_fd); >>>> - >>>> - plane_set_prop(req, plane, IGT_PLANE_CRTC_ID, plane- >>>>> crtc_id); >>>> - plane_set_prop(req, plane, IGT_PLANE_FB_ID, plane- >>>>> fb_id); >>>> - plane_set_prop(req, plane, IGT_PLANE_SRC_X, plane- >>>>> src_x); >>>> - plane_set_prop(req, plane, IGT_PLANE_SRC_Y, plane- >>>>> src_y); >>>> - plane_set_prop(req, plane, IGT_PLANE_SRC_W, plane- >>>>> src_w); >>>> - plane_set_prop(req, plane, IGT_PLANE_SRC_H, plane- >>>>> src_h); >>>> - plane_set_prop(req, plane, IGT_PLANE_CRTC_X, plane- >>>>> crtc_x); >>>> - plane_set_prop(req, plane, IGT_PLANE_CRTC_Y, plane- >>>>> crtc_y); >>>> - plane_set_prop(req, plane, IGT_PLANE_CRTC_W, plane- >>>>> crtc_w); >>>> - plane_set_prop(req, plane, IGT_PLANE_CRTC_H, plane- >>>>> crtc_h); >>>> -} >>>> - >>>> -static void plane_get_current_state(struct >>>> kms_atomic_plane_state >>>> *plane) >>>> -{ >>>> - struct kms_atomic_desc *desc = plane->state->desc; >>>> - drmModeObjectPropertiesPtr props; >>>> - int i; >>>> - >>>> - props = drmModeObjectGetProperties(desc->fd, plane->obj, >>>> - DRM_MODE_OBJECT_PLANE >>>> ); >>>> - igt_assert(props); >>>> - >>>> - for (i = 0; i < props->count_props; i++) { >>>> - uint32_t *prop_ids = desc->props_plane; >>>> - >>>> - if (props->props[i] == >>>> prop_ids[IGT_PLANE_CRTC_ID]) >>>> - plane->crtc_id = props->prop_values[i]; >>>> - else if (props->props[i] == >>>> prop_ids[IGT_PLANE_FB_ID]) >>>> - plane->fb_id = props->prop_values[i]; >>>> - else if (props->props[i] == >>>> prop_ids[IGT_PLANE_CRTC_X]) >>>> - plane->crtc_x = props->prop_values[i]; >>>> - else if (props->props[i] == >>>> prop_ids[IGT_PLANE_CRTC_Y]) >>>> - plane->crtc_y = props->prop_values[i]; >>>> - else if (props->props[i] == >>>> prop_ids[IGT_PLANE_CRTC_W]) >>>> - plane->crtc_w = props->prop_values[i]; >>>> - else if (props->props[i] == >>>> prop_ids[IGT_PLANE_CRTC_H]) >>>> - plane->crtc_h = props->prop_values[i]; >>>> - else if (props->props[i] == >>>> prop_ids[IGT_PLANE_SRC_X]) >>>> - plane->src_x = props->prop_values[i]; >>>> - else if (props->props[i] == >>>> prop_ids[IGT_PLANE_SRC_Y]) >>>> - plane->src_y = props->prop_values[i]; >>>> - else if (props->props[i] == >>>> prop_ids[IGT_PLANE_SRC_W]) >>>> - plane->src_w = props->prop_values[i]; >>>> - else if (props->props[i] == >>>> prop_ids[IGT_PLANE_SRC_H]) >>>> - plane->src_h = props->prop_values[i]; >>>> - else if (props->props[i] == >>>> prop_ids[IGT_PLANE_TYPE]) { >>>> - int j; >>>> - >>>> - for (j = 0; j < ARRAY_SIZE(desc- >>>>> props_plane_type); j++) { >>>> - if (props->prop_values[i] == >>>> desc- >>>>> props_plane_type[j]) { >>>> - plane->type = j; >>>> - break; >>>> - } >>>> - } >>>> } >>>> - } >>>> >>>> - drmModeFreeObjectProperties(props); >>>> + values[i] = igt_plane_get_prop(plane, i); >>>> + } >>>> } >>>> >>>> -static void plane_check_current_state(struct >>>> kms_atomic_plane_state >>>> *plane, >>>> +static void plane_check_current_state(igt_plane_t *plane, const >>>> uint64_t *values, >>>> enum >>>> kms_atomic_check_relax >>>> relax) >>>> { >>>> drmModePlanePtr legacy; >>>> - struct kms_atomic_plane_state plane_kernel; >>>> + uint64_t current_values[IGT_NUM_PLANE_PROPS]; >>>> + int i; >>>> >>>> - legacy = drmModeGetPlane(plane->state->desc->fd, plane- >>>>> obj); >>>> + legacy = drmModeGetPlane(plane->pipe->display->drm_fd, >>>> plane->drm_plane->plane_id); >>>> igt_assert(legacy); >>>> >>>> - igt_assert_eq_u32(legacy->crtc_id, plane->crtc_id); >>>> + igt_assert_eq_u32(legacy->crtc_id, >>>> values[IGT_PLANE_CRTC_ID]); >>>> >>>> if (!(relax & PLANE_RELAX_FB)) >>>> - igt_assert_eq_u32(legacy->fb_id, plane->fb_id); >>>> + igt_assert_eq_u32(legacy->fb_id, >>>> values[IGT_PLANE_FB_ID]); >>>> >>>> - memcpy(&plane_kernel, plane, sizeof(plane_kernel)); >>>> - plane_get_current_state(&plane_kernel); >>>> + plane_get_current_state(plane, current_values); >>>> >>>> /* Legacy cursor ioctls create their own, unknowable, >>>> internal >>>> * framebuffer which we can't reason about. */ >>>> if (relax & PLANE_RELAX_FB) >>>> - plane_kernel.fb_id = plane->fb_id; >>>> - do_or_die(memcmp(&plane_kernel, plane, >>>> sizeof(plane_kernel))); >>>> + current_values[IGT_PLANE_FB_ID] = >>>> values[IGT_PLANE_FB_ID]; >>>> + >>>> + for (i = 0; i < IGT_NUM_PLANE_PROPS; i++) >>>> + if (!plane_filter(i)) >>>> + igt_assert_eq_u64(current_values[i], >>>> values[i]); >>>> >>>> drmModeFreePlane(legacy); >>>> } >>>> >>>> -static void plane_commit_legacy(struct kms_atomic_plane_state >>>> *plane, >>>> +static void plane_commit(igt_plane_t *plane, enum >>>> igt_commit_style >>>> s, >>>> enum kms_atomic_check_relax >>>> relax) >>>> { >>>> - do_or_die(drmModeSetPlane(plane->state->desc->fd, plane- >>>>> obj, >>>> - plane->crtc_id, >>>> - plane->fb_id, 0, >>>> - plane->crtc_x, plane->crtc_y, >>>> - plane->crtc_w, plane->crtc_h, >>>> - plane->src_x, plane->src_y, >>>> - plane->src_w, plane->src_h)); >>>> - plane_check_current_state(plane, relax); >>>> + igt_display_commit2(plane->pipe->display, s); >>>> + plane_check_current_state(plane, plane->values, relax); >>>> } >>>> >>>> -static struct kms_atomic_plane_state * >>>> -find_plane(struct kms_atomic_state *state, enum plane_type type, >>>> - struct kms_atomic_crtc_state *crtc) >>>> +static void plane_commit_atomic_err(igt_plane_t *plane, >>>> + enum kms_atomic_check_relax >>>> relax, >>>> + int err) >>>> { >>>> - struct kms_atomic_plane_state *ret = NULL; >>>> - int i; >>>> - >>>> - for (i = 0; i < state->num_planes; i++) { >>>> - struct kms_atomic_plane_state *plane = &state- >>>>> planes[i]; >>>> - >>>> - if (!plane->obj) >>>> - continue; >>>> - if (type != NUM_PLANE_TYPE_PROPS && plane->type >>>> != >>>> type) >>>> - continue; >>>> - if (crtc && !(plane->crtc_mask & (1 << crtc- >>>>> idx))) >>>> - continue; >>>> + uint64_t current_values[IGT_NUM_PLANE_PROPS]; >>>> >>>> - plane_get_current_state(plane); >>>> + plane_get_current_state(plane, current_values); >>>> >>>> - /* Try to find a plane that's already on this >>>> CRTC. >>>> In >>>> - * particular, this ensures that for special >>>> (primary/cursor) >>>> - * planes that can be on multiple CRTCs, we find >>>> the >>>> same >>>> - * one that the legacy ioctls will. */ >>>> - if (!crtc || plane->crtc_id == crtc->obj) >>>> - return plane; >>>> - >>>> - ret = plane; >>>> - } >>>> + igt_assert_eq(-err, igt_display_try_commit2(plane->pipe- >>>>> display, COMMIT_ATOMIC)); >>>> >>>> - return ret; >>>> + plane_check_current_state(plane, current_values, relax); >>>> } >>>> >>>> -static void crtc_populate_req(struct kms_atomic_crtc_state >>>> *crtc, >>>> - drmModeAtomicReq *req) >>>> +static bool crtc_filter(enum igt_atomic_crtc_properties prop) >>>> { >>>> - if (crtc->out_fence_ptr) >>>> - crtc_set_prop(req, crtc, IGT_CRTC_OUT_FENCE_PTR, >>>> - to_user_pointer(crtc- >>>>> out_fence_ptr)); >>>> + if (prop == IGT_CRTC_MODE_ID || prop == IGT_CRTC_ACTIVE) >>>> + return false; >>>> >>>> - crtc_set_prop(req, crtc, IGT_CRTC_MODE_ID, crtc- >>>>> mode.id); >>>> - crtc_set_prop(req, crtc, IGT_CRTC_ACTIVE, crtc->active); >>>> + return true; >>>> } >>>> >>>> -static void crtc_get_current_state(struct kms_atomic_crtc_state >>>> *crtc) >>>> +static void crtc_get_current_state(igt_pipe_t *pipe, uint64_t >>>> *values) >>>> { >>>> - drmModeObjectPropertiesPtr props; >>>> int i; >>>> >>>> - props = drmModeObjectGetProperties(crtc->state->desc- >>>>> fd, >>>> crtc->obj, >>>> - DRM_MODE_OBJECT_CRTC) >>>> ; >>>> - igt_assert(props); >>>> - >>>> - for (i = 0; i < props->count_props; i++) { >>>> - uint32_t *prop_ids = crtc->state->desc- >>>>> props_crtc; >>>> - >>>> - if (props->props[i] == >>>> prop_ids[IGT_CRTC_MODE_ID]) { >>>> - drmModePropertyBlobPtr blob; >>>> - >>>> - crtc->mode.id = props->prop_values[i]; >>>> - if (!crtc->mode.id) { >>>> - crtc->mode.len = 0; >>>> - continue; >>>> - } >>>> - >>>> - blob = drmModeGetPropertyBlob(crtc- >>>>> state- >>>>> >>>>> desc->fd, >>>> - crtc- >>>>> mode.id); >>>> - igt_assert(blob); >>>> - igt_assert_eq_u32(blob->length, >>>> - sizeof(struct >>>> drm_mode_modeinfo)); >>>> - >>>> - if (!crtc->mode.data || >>>> - memcmp(crtc->mode.data, blob->data, >>>> blob->length) != 0) >>>> - crtc->mode.data = blob->data; >>>> - crtc->mode.len = blob->length; >>>> - } >>>> - else if (props->props[i] == >>>> prop_ids[IGT_CRTC_ACTIVE]) { >>>> - crtc->active = props->prop_values[i]; >>>> + for (i = 0; i < IGT_NUM_CRTC_PROPS; i++) { >>>> + if (crtc_filter(i)) { >>>> + values[i] = 0; >>>> + continue; >>>> } >>>> - } >>>> >>>> - drmModeFreeObjectProperties(props); >>>> + values[i] = igt_pipe_obj_get_prop(pipe, i); >>>> + } >>>> } >>>> >>>> -static void crtc_check_current_state(struct >>>> kms_atomic_crtc_state >>>> *crtc, >>>> - struct >>>> kms_atomic_plane_state >>>> *primary, >>>> +static void crtc_check_current_state(igt_pipe_t *pipe, >>>> + const uint64_t >>>> *pipe_values, >>>> + const uint64_t >>>> *primary_values, >>>> enum kms_atomic_check_relax >>>> relax) >>>> { >>>> - struct kms_atomic_crtc_state crtc_kernel; >>>> + uint64_t current_pipe_values[IGT_NUM_CRTC_PROPS]; >>>> drmModeCrtcPtr legacy; >>>> + drmModePropertyBlobRes *mode_prop = NULL; >>>> + struct drm_mode_modeinfo *mode = NULL; >>>> >>>> - legacy = drmModeGetCrtc(crtc->state->desc->fd, crtc- >>>>> obj); >>>> - igt_assert(legacy); >>>> - >>>> - igt_assert_eq_u32(legacy->crtc_id, crtc->obj); >>>> - igt_assert_eq_u32(legacy->x, primary->src_x >> 16); >>>> - igt_assert_eq_u32(legacy->y, primary->src_y >> 16); >>>> - >>>> - if (crtc->active) >>>> - igt_assert_eq_u32(legacy->buffer_id, primary- >>>>> fb_id); >>>> - else >>>> - igt_assert_eq_u32(legacy->buffer_id, 0); >>>> + if (pipe_values[IGT_CRTC_MODE_ID]) { >>>> + mode_prop = drmModeGetPropertyBlob(pipe- >>>>> display- >>>>> >>>>> drm_fd, >>>> + pipe_values[I >>>> GT_C >>>> RTC_MODE_ID]); >>>> >>>> - if (legacy->mode_valid) { >>>> - igt_assert_neq(legacy->mode_valid, 0); >>>> - igt_assert_eq(crtc->mode.len, >>>> - sizeof(struct drm_mode_modeinfo)); >>>> - do_or_die(memcmp(&legacy->mode, crtc->mode.data, >>>> - crtc->mode.len)); >>>> - igt_assert_eq(legacy->width, legacy- >>>>> mode.hdisplay); >>>> - igt_assert_eq(legacy->height, legacy- >>>>> mode.vdisplay); >>>> - } else { >>>> - igt_assert_eq(legacy->mode_valid, 0); >>>> - } >>>> + igt_assert(mode_prop); >>>> >>>> - memcpy(&crtc_kernel, crtc, sizeof(crtc_kernel)); >>>> - crtc_get_current_state(&crtc_kernel); >>>> - >>>> - if (crtc_kernel.mode.id != 0) >>>> - igt_assert_eq(crtc_kernel.mode.len, >>>> + igt_assert_eq(mode_prop->length, >>>> sizeof(struct drm_mode_modeinfo)); >>>> - >>>> - /* Optionally relax the check for MODE_ID: using the >>>> legacy >>>> SetCrtc >>>> - * API can potentially change MODE_ID even if the mode >>>> itself remains >>>> - * unchanged. */ >>>> - if (((relax & CRTC_RELAX_MODE) && >>>> - (crtc_kernel.mode.id != crtc->mode.id && >>>> - crtc_kernel.mode.id != 0 && crtc->mode.id != 0)) && >>>> - memcmp(crtc_kernel.mode.data, crtc->mode.data, >>>> - sizeof(struct drm_mode_modeinfo)) == 0) { >>>> - crtc_kernel.mode.id = crtc->mode.id; >>>> - crtc_kernel.mode.data = crtc->mode.data; >>>> - } >>>> - >>>> - do_or_die(memcmp(&crtc_kernel, crtc, >>>> sizeof(crtc_kernel))); >>>> - >>>> - drmModeFreeCrtc(legacy); >>>> -} >>>> - >>>> -static void crtc_commit_legacy(struct kms_atomic_crtc_state >>>> *crtc, >>>> - struct kms_atomic_plane_state >>>> *plane, >>>> - enum kms_atomic_check_relax >>>> relax) >>>> -{ >>>> - drmModeObjectPropertiesPtr props; >>>> - uint32_t *connectors; >>>> - int num_connectors = 0; >>>> - int i; >>>> - >>>> - if (!crtc->active) { >>>> - do_or_die(drmModeSetCrtc(crtc->state->desc->fd, >>>> - crtc->obj, 0, 0, 0, >>>> NULL, >>>> 0, NULL)); >>>> - return; >>>> - } >>>> - >>>> - connectors = calloc(crtc->state->num_connectors, >>>> - sizeof(*connectors)); >>>> - igt_assert(connectors); >>>> - >>>> - igt_assert_neq_u32(crtc->mode.id, 0); >>>> - >>>> - for (i = 0; i < crtc->state->num_connectors; i++) { >>>> - struct kms_atomic_connector_state *connector = >>>> - &crtc->state->connectors[i]; >>>> - >>>> - if (connector->crtc_id != crtc->obj) >>>> - continue; >>>> - >>>> - connectors[num_connectors++] = connector->obj; >>>> + mode = mode_prop->data; >>>> } >>>> >>>> - do_or_die(drmModeSetCrtc(crtc->state->desc->fd, crtc- >>>>> obj, >>>> - plane->fb_id, >>>> - plane->src_x >> 16, plane- >>>>> src_y >> >>>> 16, >>>> - (num_connectors) ? connectors : >>>> NULL, >>>> - num_connectors, >>>> - crtc->mode.data)); >>>> - /* When doing a legacy commit, the core may update >>>> MODE_ID >>>> to be a new >>>> - * blob implicitly created by the legacy request. Hence >>>> we >>>> backfill >>>> - * the value in the state object to ensure they match. >>>> */ >>>> - props = drmModeObjectGetProperties(crtc->state->desc- >>>>> fd, >>>> crtc->obj, >>>> - DRM_MODE_OBJECT_CRTC) >>>> ; >>>> - igt_assert(props); >>>> - >>>> - for (i = 0; i < props->count_props; i++) { >>>> - if (props->props[i] != >>>> - crtc->state->desc- >>>>> props_crtc[IGT_CRTC_MODE_ID]) >>>> - continue; >>>> - crtc->mode.id = props->prop_values[i]; >>>> - break; >>>> - } >>>> + legacy = drmModeGetCrtc(pipe->display->drm_fd, pipe- >>>>> crtc_id); >>>> + igt_assert(legacy); >>>> >>>> - drmModeFreeObjectProperties(props); >>>> + igt_assert_eq_u32(legacy->crtc_id, pipe->crtc_id); >>>> + igt_assert_eq_u32(legacy->x, >>>> primary_values[IGT_PLANE_SRC_X] >>>>>> 16); >>>> + igt_assert_eq_u32(legacy->y, >>>> primary_values[IGT_PLANE_SRC_Y] >>>>>> 16); >>>> >>>> - crtc_check_current_state(crtc, plane, relax); >>>> - plane_check_current_state(plane, relax); >>>> -} >>>> + igt_assert_eq_u32(legacy->buffer_id, >>>> primary_values[IGT_PLANE_FB_ID]); >>>> >>>> -static struct kms_atomic_crtc_state *find_crtc(struct >>>> kms_atomic_state *state, >>>> - bool >>>> must_be_enabled) >>>> -{ >>>> - int i; >>>> + if (legacy->mode_valid) { >>>> + igt_assert(mode_prop); >>>> >>>> - for (i = 0; i < state->num_crtcs; i++) { >>>> - struct kms_atomic_crtc_state *crtc = &state- >>>>> crtcs[i]; >>>> + do_or_die(memcmp(&legacy->mode, mode, >>>> sizeof(*mode))); >>>> >>>> - if (!crtc->obj) >>>> - continue; >>>> - if (must_be_enabled && !crtc->active) >>>> - continue; >>>> + igt_assert_eq(legacy->width, legacy- >>>>> mode.hdisplay); >>>> + igt_assert_eq(legacy->height, legacy- >>>>> mode.vdisplay); >>>> >>>> - crtc_get_current_state(crtc); >>>> - return crtc; >>>> + igt_assert_neq(pipe_values[IGT_CRTC_MODE_ID], >>>> 0); >>>> + } else { >>>> + igt_assert(!mode_prop); >>>> } >>>> >>>> - return NULL; >>>> -} >>>> + crtc_get_current_state(pipe, current_pipe_values); >>>> >>>> -static void fill_obj_props(int fd, uint32_t id, int type, int >>>> num_props, >>>> - const char **prop_names, uint32_t >>>> *prop_ids) >>>> -{ >>>> - drmModeObjectPropertiesPtr props; >>>> - int i, j; >>>> - >>>> - props = drmModeObjectGetProperties(fd, id, type); >>>> - igt_assert(props); >>>> + /* Optionally relax the check for MODE_ID: using the >>>> legacy >>>> SetCrtc >>>> + * API can potentially change MODE_ID even if the mode >>>> itself remains >>>> + * unchanged. */ >>>> + if (relax & CRTC_RELAX_MODE && mode && >>>> current_pipe_values[IGT_CRTC_MODE_ID] && >>>> + current_pipe_values[IGT_CRTC_MODE_ID] != >>>> pipe_values[IGT_CRTC_MODE_ID]) { >>>> + drmModePropertyBlobRes *cur_prop = >>>> + drmModeGetPropertyBlob(pipe->display- >>>>> drm_fd, >>>> + current_pipe_valu >>>> es[I >>>> GT_CRTC_MODE_ID]); >>>> >>>> - for (i = 0; i < props->count_props; i++) { >>>> - drmModePropertyPtr prop = >>>> - drmModeGetProperty(fd, props->props[i]); >>>> + igt_assert(cur_prop); >>>> + igt_assert_eq(cur_prop->length, sizeof(struct >>>> drm_mode_modeinfo)); >>>> >>>> - for (j = 0; j < num_props; j++) { >>>> - if (strcmp(prop->name, prop_names[j]) != >>>> 0) >>>> - continue; >>>> - prop_ids[j] = props->props[i]; >>>> - break; >>>> - } >>>> + if (!memcmp(cur_prop->data, mode, >>>> sizeof(*mode))) >>>> + current_pipe_values[IGT_CRTC_MODE_ID] = >>>> pipe_values[IGT_CRTC_MODE_ID]; >>>> >>>> - drmModeFreeProperty(prop); >>>> + drmModeFreePropertyBlob(cur_prop); >>>> } >>>> >>>> - drmModeFreeObjectProperties(props); >>>> -} >>>> + do_or_die(memcmp(pipe_values, current_pipe_values, >>>> sizeof(current_pipe_values))); >>>> >>>> -static void fill_obj_prop_map(int fd, uint32_t id, int type, >>>> const >>>> char *name, >>>> - int num_enums, const char >>>> **enum_names, >>>> - uint64_t *enum_ids) >>>> -{ >>>> - drmModeObjectPropertiesPtr props; >>>> - int i, j, k; >>>> - >>>> - props = drmModeObjectGetProperties(fd, id, type); >>>> - igt_assert(props); >>>> - >>>> - for (i = 0; i < props->count_props; i++) { >>>> - drmModePropertyPtr prop = >>>> - drmModeGetProperty(fd, props->props[i]); >>>> - >>>> - igt_assert(prop); >>>> - >>>> - if (strcmp(prop->name, name) != 0) { >>>> - drmModeFreeProperty(prop); >>>> - continue; >>>> - } >>>> - >>>> - for (j = 0; j < prop->count_enums; j++) { >>>> - struct drm_mode_property_enum *e = >>>> &prop- >>>>> enums[j]; >>>> - >>>> - for (k = 0; k < num_enums; k++) { >>>> - if (strcmp(e->name, >>>> enum_names[k]) >>>> != 0) >>>> - continue; >>>> - >>>> - enum_ids[k] = e->value; >>>> - break; >>>> - } >>>> - } >>>> - >>>> - drmModeFreeProperty(prop); >>>> - } >>>> + drmModeFreeCrtc(legacy); >>>> + drmModeFreePropertyBlob(mode_prop); >>>> } >>>> >>>> -static void atomic_setup(struct kms_atomic_state *state) >>>> +static void crtc_commit(igt_pipe_t *pipe, igt_plane_t *plane, >>>> + enum igt_commit_style s, >>>> + enum kms_atomic_check_relax relax) >>>> { >>>> - struct kms_atomic_desc *desc = state->desc; >>>> - drmModeResPtr res; >>>> - drmModePlaneResPtr res_plane; >>>> - int i; >>>> - >>>> - desc->fd = drm_open_driver_master(DRIVER_ANY); >>>> - igt_assert_fd(desc->fd); >>>> - >>>> - igt_skip_on(drmSetClientCap(desc->fd, >>>> DRM_CLIENT_CAP_ATOMIC, >>>> 1)); >>>> - >>>> - res = drmModeGetResources(desc->fd); >>>> - res_plane = drmModeGetPlaneResources(desc->fd); >>>> - igt_assert(res); >>>> - igt_assert(res_plane); >>>> - >>>> - igt_assert_lt(0, res->count_crtcs); >>>> - state->num_crtcs = res->count_crtcs; >>>> - state->crtcs = calloc(state->num_crtcs, sizeof(*state- >>>>> crtcs)); >>>> - igt_assert(state->crtcs); >>>> - >>>> - igt_assert_lt(0, res_plane->count_planes); >>>> - state->num_planes = res_plane->count_planes; >>>> - state->planes = calloc(state->num_planes, sizeof(*state- >>>>> planes)); >>>> - igt_assert(state->planes); >>>> - >>>> - igt_assert_lt(0, res->count_connectors); >>>> - state->num_connectors = res->count_connectors; >>>> - state->connectors = calloc(state->num_connectors, >>>> - sizeof(*state->connectors)); >>>> - igt_assert(state->connectors); >>>> - >>>> - fill_obj_props(desc->fd, res->crtcs[0], >>>> - DRM_MODE_OBJECT_CRTC, IGT_NUM_CRTC_PROPS, >>>> - igt_crtc_prop_names, desc->props_crtc); >>>> - >>>> - fill_obj_props(desc->fd, res_plane->planes[0], >>>> - DRM_MODE_OBJECT_PLANE, >>>> IGT_NUM_PLANE_PROPS, >>>> - igt_plane_prop_names, desc->props_plane); >>>> - fill_obj_prop_map(desc->fd, res_plane->planes[0], >>>> - DRM_MODE_OBJECT_PLANE, "type", >>>> - NUM_PLANE_TYPE_PROPS, >>>> plane_type_prop_names, >>>> - desc->props_plane_type); >>>> - >>>> - fill_obj_props(desc->fd, res->connectors[0], >>>> - DRM_MODE_OBJECT_CONNECTOR, >>>> IGT_NUM_CONNECTOR_PROPS, >>>> - igt_connector_prop_names, desc- >>>>> props_connector); >>>> - >>>> - for (i = 0; i < state->num_crtcs; i++) { >>>> - struct kms_atomic_crtc_state *crtc = &state- >>>>> crtcs[i]; >>>> - >>>> - crtc->state = state; >>>> - crtc->obj = res->crtcs[i]; >>>> - crtc->idx = i; >>>> - crtc_get_current_state(crtc); >>>> - >>>> - /* The blob pointed to by MODE_ID could well be >>>> transient, >>>> - * and lose its last reference as we switch away >>>> from it. >>>> - * Duplicate the blob here so we have a >>>> reference we >>>> know we >>>> - * own. */ >>>> - if (crtc->mode.id != 0) >>>> - crtc->mode.id = blob_duplicate(desc->fd, >>>> crtc- >>>>> mode.id); >>>> - } >>>> + igt_display_commit2(pipe->display, s); >>>> >>>> - for (i = 0; i < state->num_planes; i++) { >>>> - drmModePlanePtr plane = >>>> - drmModeGetPlane(desc->fd, res_plane- >>>>> planes[i]); >>>> - igt_assert(plane); >>>> - >>>> - state->planes[i].state = state; >>>> - state->planes[i].obj = res_plane->planes[i]; >>>> - state->planes[i].crtc_mask = plane- >>>>> possible_crtcs; >>>> - plane_get_current_state(&state->planes[i]); >>>> - } >>>> - >>>> - for (i = 0; i < state->num_connectors; i++) { >>>> - state->connectors[i].state = state; >>>> - state->connectors[i].obj = res->connectors[i]; >>>> - connector_get_current_state(&state- >>>>> connectors[i]); >>>> - } >>>> - >>>> - drmModeFreePlaneResources(res_plane); >>>> - drmModeFreeResources(res); >>>> + crtc_check_current_state(pipe, pipe->values, plane- >>>>> values, >>>> relax); >>>> + plane_check_current_state(plane, plane->values, relax); >>>> } >>>> >>>> -static struct kms_atomic_state * >>>> -atomic_state_dup(const struct kms_atomic_state *state) >>>> +static void crtc_commit_atomic_flags_err(igt_pipe_t *pipe, >>>> igt_plane_t *plane, >>>> + unsigned flags, >>>> + enum >>>> kms_atomic_check_relax >>>> relax, >>>> + int err) >>>> { >>>> - struct kms_atomic_state *ret = calloc(1, sizeof(*ret)); >>>> - >>>> - igt_assert(ret); >>>> - *ret = *state; >>>> + uint64_t current_pipe_values[IGT_NUM_CRTC_PROPS]; >>>> + uint64_t current_plane_values[IGT_NUM_PLANE_PROPS]; >>>> >>>> - ret->crtcs = calloc(ret->num_crtcs, sizeof(*ret- >>>>> crtcs)); >>>> - igt_assert(ret->crtcs); >>>> - memcpy(ret->crtcs, state->crtcs, ret->num_crtcs * >>>> sizeof(*ret->crtcs)); >>>> + crtc_get_current_state(pipe, current_pipe_values); >>>> + plane_get_current_state(plane, current_plane_values); >>>> >>>> - ret->planes = calloc(ret->num_planes, sizeof(*ret- >>>>> planes)); >>>> - igt_assert(ret->planes); >>>> - memcpy(ret->planes, state->planes, >>>> - ret->num_planes * sizeof(*ret->planes)); >>>> + igt_assert_eq(-err, igt_display_try_commit_atomic(pipe- >>>>> display, flags, NULL)); >>>> >>>> - ret->connectors = calloc(ret->num_connectors, >>>> sizeof(*ret- >>>>> connectors)); >>>> - igt_assert(ret->connectors); >>>> - memcpy(ret->connectors, state->connectors, >>>> - ret->num_connectors * sizeof(*ret->connectors)); >>>> - >>>> - return ret; >>>> + crtc_check_current_state(pipe, current_pipe_values, >>>> current_plane_values, relax); >>>> + plane_check_current_state(plane, current_plane_values, >>>> relax); >>>> } >>>> >>>> -static void atomic_state_free(struct kms_atomic_state *state) >>>> -{ >>>> - free(state->crtcs); >>>> - free(state->planes); >>>> - free(state->connectors); >>>> - free(state); >>>> -} >>>> +#define crtc_commit_atomic_err(pipe, plane, relax, err) \ >>>> + crtc_commit_atomic_flags_err(pipe, plane, >>>> DRM_MODE_ATOMIC_ALLOW_MODESET, relax, err) >>>> >>>> -static uint32_t plane_get_igt_format(struct >>>> kms_atomic_plane_state >>>> *plane) >>>> +static uint32_t plane_get_igt_format(igt_plane_t *plane) >>>> { >>>> drmModePlanePtr plane_kms; >>>> const uint32_t *igt_formats; >>>> - uint32_t ret = 0; >>>> int num_igt_formats; >>>> int i; >>>> >>>> - plane_kms = drmModeGetPlane(plane->state->desc->fd, >>>> plane- >>>>> obj); >>>> - igt_assert(plane_kms); >>>> + plane_kms = plane->drm_plane; >>>> >>>> igt_get_all_cairo_formats(&igt_formats, >>>> &num_igt_formats); >>>> for (i = 0; i < num_igt_formats; i++) { >>>> int j; >>>> >>>> for (j = 0; j < plane_kms->count_formats; j++) { >>>> - if (plane_kms->formats[j] == >>>> igt_formats[i]) >>>> { >>>> - ret = plane_kms->formats[j]; >>>> - break; >>>> - } >>>> + if (plane_kms->formats[j] == >>>> igt_formats[i]) >>>> + return plane_kms->formats[j]; >>>> } >>>> } >>>> >>>> - drmModeFreePlane(plane_kms); >>>> - return ret; >>>> + return 0; >>>> } >>>> >>>> static void >>>> -set_dpms(int fd, int mode) >>>> +set_dpms(igt_output_t *output, int mode) >>>> { >>>> - int i; >>>> - drmModeConnector *connector; >>>> - uint32_t id; >>>> - drmModeRes *resources = drmModeGetResources(fd); >>>> - >>>> - for (i = 0; i < resources->count_connectors; i++) { >>>> - id = resources->connectors[i]; >>>> - >>>> - connector = drmModeGetConnectorCurrent(fd, id); >>>> - >>>> - kmstest_set_connector_dpms(fd, connector, mode); >>>> - >>>> - drmModeFreeConnector(connector); >>>> - } >>>> + do_or_die(drmModeConnectorSetProperty(output->display- >>>>> drm_fd, output->id, >>>> + output- >>>>> props[IGT_CONNECTOR_DPMS], mode)); >>>> } >>>> >>>> -static void plane_overlay(struct kms_atomic_crtc_state *crtc, >>>> - struct kms_atomic_plane_state >>>> *plane_old) >>>> +static void plane_overlay(igt_pipe_t *pipe, igt_output_t >>>> *output, >>>> igt_plane_t *plane) >>>> { >>>> - struct drm_mode_modeinfo *mode = crtc->mode.data; >>>> - struct kms_atomic_plane_state plane = *plane_old; >>>> - uint32_t format = plane_get_igt_format(&plane); >>>> - drmModeAtomicReq *req = drmModeAtomicAlloc(); >>>> + drmModeModeInfo *mode = igt_output_get_mode(output); >>>> + uint32_t format = plane_get_igt_format(plane); >>>> struct igt_fb fb; >>>> + uint32_t w = mode->hdisplay / 2; >>>> + uint32_t h = mode->vdisplay / 2; >>>> >>>> - igt_require(req); >>>> igt_require(format != 0); >>>> >>>> - plane.src_x = 0; >>>> - plane.src_y = 0; >>>> - plane.src_w = (mode->hdisplay / 2) << 16; >>>> - plane.src_h = (mode->vdisplay / 2) << 16; >>>> - plane.crtc_x = mode->hdisplay / 4; >>>> - plane.crtc_y = mode->vdisplay / 4; >>>> - plane.crtc_w = mode->hdisplay / 2; >>>> - plane.crtc_h = mode->vdisplay / 2; >>>> - plane.crtc_id = crtc->obj; >>>> - plane.fb_id = igt_create_pattern_fb(plane.state->desc- >>>>> fd, >>>> - plane.crtc_w, >>>> plane.crtc_h, >>>> - format, >>>> I915_TILING_NONE, &fb); >>>> + igt_create_pattern_fb(pipe->display->drm_fd, w, h, >>>> + format, I915_TILING_NONE, &fb); >>>> + >>>> + igt_plane_set_fb(plane, &fb); >>>> + igt_plane_set_position(plane, w/2, h/2); >>>> >>>> /* Enable the overlay plane using the atomic API, and >>>> double-check >>>> * state is what we think it should be. */ >>>> - plane_commit_atomic(&plane, req, ATOMIC_RELAX_NONE); >>>> + plane_commit(plane, COMMIT_ATOMIC, ATOMIC_RELAX_NONE); >>>> >>>> /* Disable the plane and check the state matches the >>>> old. */ >>>> - plane_commit_atomic(plane_old, req, ATOMIC_RELAX_NONE); >>>> + igt_plane_set_fb(plane, NULL); >>>> + igt_plane_set_position(plane, 0, 0); >>>> + plane_commit(plane, COMMIT_ATOMIC, ATOMIC_RELAX_NONE); >>>> >>>> /* Re-enable the plane through the legacy plane API, and >>>> verify through >>>> * atomic. */ >>>> - plane_commit_legacy(&plane, ATOMIC_RELAX_NONE); >>>> + igt_plane_set_fb(plane, &fb); >>>> + igt_plane_set_position(plane, w/2, h/2); >>>> + plane_commit(plane, COMMIT_LEGACY, ATOMIC_RELAX_NONE); >>>> >>>> /* Restore the plane to its original settings through >>>> the >>>> legacy plane >>>> * API, and verify through atomic. */ >>>> - plane_commit_legacy(plane_old, ATOMIC_RELAX_NONE); >>>> + igt_plane_set_fb(plane, NULL); >>>> + igt_plane_set_position(plane, 0, 0); >>>> + plane_commit(plane, COMMIT_LEGACY, ATOMIC_RELAX_NONE); >>>> >>>> - drmModeAtomicFree(req); >>>> + igt_remove_fb(pipe->display->drm_fd, &fb); >>>> } >>>> >>>> -static void plane_primary(struct kms_atomic_crtc_state *crtc, >>>> - struct kms_atomic_plane_state >>>> *plane_old) >>>> +static void plane_primary(igt_pipe_t *pipe, igt_plane_t *plane, >>>> struct igt_fb *fb) >>>> { >>>> - struct drm_mode_modeinfo *mode = crtc->mode.data; >>>> - struct kms_atomic_plane_state plane = *plane_old; >>>> - uint32_t format = plane_get_igt_format(&plane); >>>> - drmModeAtomicReq *req = drmModeAtomicAlloc(); >>>> - struct igt_fb fb; >>>> - uint32_t flags = 0; >>>> - int ret; >>>> - >>>> - igt_require(format != 0); >>>> + struct igt_fb fb2; >>>> >>>> - plane.src_x = 0; >>>> - plane.src_y = 0; >>>> - plane.src_w = mode->hdisplay << 16; >>>> - plane.src_h = mode->vdisplay << 16; >>>> - plane.crtc_x = 0; >>>> - plane.crtc_y = 0; >>>> - plane.crtc_w = mode->hdisplay; >>>> - plane.crtc_h = mode->vdisplay; >>>> - plane.crtc_id = crtc->obj; >>>> - plane.fb_id = igt_create_pattern_fb(plane.state->desc- >>>>> fd, >>>> - plane.crtc_w, >>>> plane.crtc_h, >>>> - format, >>>> I915_TILING_NONE, &fb); >>>> - >>>> - drmModeAtomicSetCursor(req, 0); >>>> - crtc_populate_req(crtc, req); >>>> - plane_populate_req(&plane, req); >>>> - ret = drmModeAtomicCommit(crtc->state->desc->fd, req, >>>> - DRM_MODE_ATOMIC_TEST_ONLY, >>>> NULL); >>>> - /* Try harder in case the failure is caused by >>>> disallowing >>>> modeset. */ >>>> - if (ret == -EINVAL) >>>> - flags |= DRM_MODE_ATOMIC_ALLOW_MODESET; >>>> + igt_create_color_pattern_fb(pipe->display->drm_fd, >>>> + fb->width, fb->height, >>>> + fb->drm_format, >>>> I915_TILING_NONE, >>>> + 0.2, 0.2, 0.2, &fb2); >>>> >>>> /* Flip the primary plane using the atomic API, and >>>> double- >>>> check >>>> * state is what we think it should be. */ >>>> - crtc_commit_atomic(crtc, &plane, req, ATOMIC_RELAX_NONE, >>>> flags); >>>> + igt_plane_set_fb(plane, &fb2); >>>> + crtc_commit(pipe, plane, COMMIT_ATOMIC, >>>> ATOMIC_RELAX_NONE); >>>> >>>> /* Restore the primary plane and check the state matches >>>> the >>>> old. */ >>>> - crtc_commit_atomic(crtc, plane_old, req, >>>> ATOMIC_RELAX_NONE, >>>> flags); >>>> + igt_plane_set_fb(plane, fb); >>>> + crtc_commit(pipe, plane, COMMIT_ATOMIC, >>>> ATOMIC_RELAX_NONE); >>>> >>>> - /* Re-enable the plane through the legacy CRTC/primary- >>>> plane >>>> API, and >>>> + /* Set the plane through the legacy CRTC/primary-plane >>>> API, >>>> and >>>> * verify through atomic. */ >>>> - crtc_commit_legacy(crtc, &plane, CRTC_RELAX_MODE); >>>> + igt_plane_set_fb(plane, &fb2); >>>> + crtc_commit(pipe, plane, COMMIT_LEGACY, >>>> CRTC_RELAX_MODE); >>>> >>>> /* Restore the plane to its original settings through >>>> the >>>> legacy CRTC >>>> * API, and verify through atomic. */ >>>> - crtc_commit_legacy(crtc, plane_old, CRTC_RELAX_MODE); >>>> - >>>> - /* Finally, restore to the original state. */ >>>> - crtc_commit_atomic(crtc, plane_old, req, >>>> ATOMIC_RELAX_NONE, >>>> flags); >>>> + igt_plane_set_fb(plane, fb); >>>> + crtc_commit(pipe, plane, COMMIT_LEGACY, >>>> CRTC_RELAX_MODE); >>>> >>>> - drmModeAtomicFree(req); >>>> + /* Set the plane through the universal setplane API, and >>>> + * verify through atomic. */ >>>> + igt_plane_set_fb(plane, &fb2); >>>> + plane_commit(plane, COMMIT_UNIVERSAL, >>>> ATOMIC_RELAX_NONE); >>>> } >>>> >>>> /* test to ensure that DRM_MODE_ATOMIC_TEST_ONLY really only >>>> touches >>>> the >>>> * free-standing state objects and nothing else. >>>> */ >>>> -static void test_only(struct kms_atomic_crtc_state *crtc, >>>> - struct kms_atomic_plane_state *plane_old) >>>> +static void test_only(igt_pipe_t *pipe_obj, >>>> + igt_plane_t *primary, >>>> + igt_output_t *output) >>>> { >>>> - struct drm_mode_modeinfo *mode = crtc->mode.data; >>>> - struct kms_atomic_plane_state plane = *plane_old; >>>> - uint32_t format = plane_get_igt_format(&plane); >>>> - drmModeAtomicReq *req = drmModeAtomicAlloc(); >>>> + drmModeModeInfo *mode = igt_output_get_mode(output); >>>> + uint32_t format = plane_get_igt_format(primary); >>>> struct igt_fb fb; >>>> - int ret; >>>> + uint64_t old_plane_values[IGT_NUM_PLANE_PROPS], >>>> old_crtc_values[IGT_NUM_CRTC_PROPS]; >>>> >>>> igt_require(format != 0); >>>> >>>> - plane.src_x = 0; >>>> - plane.src_y = 0; >>>> - plane.src_w = mode->hdisplay << 16; >>>> - plane.src_h = mode->vdisplay << 16; >>>> - plane.crtc_x = 0; >>>> - plane.crtc_y = 0; >>>> - plane.crtc_w = mode->hdisplay; >>>> - plane.crtc_h = mode->vdisplay; >>>> - plane.crtc_id = crtc->obj; >>>> - plane.fb_id = igt_create_pattern_fb(plane.state->desc- >>>>> fd, >>>> - plane.crtc_w, >>>> plane.crtc_h, >>>> - format, >>>> I915_TILING_NONE, &fb); >>>> - >>>> - drmModeAtomicSetCursor(req, 0); >>>> - crtc_populate_req(crtc, req); >>>> - plane_populate_req(&plane, req); >>>> - ret = drmModeAtomicCommit(crtc->state->desc->fd, req, >>>> - DRM_MODE_ATOMIC_TEST_ONLY, >>>> NULL); >>>> - >>>> - igt_assert_eq(ret, 0); >>>> - >>>> - /* go through dpms off/on cycle */ >>>> - set_dpms(crtc->state->desc->fd, DRM_MODE_DPMS_OFF); >>>> - set_dpms(crtc->state->desc->fd, DRM_MODE_DPMS_ON); >>>> - >>>> - /* check the state */ >>>> - crtc_check_current_state(crtc, plane_old, >>>> ATOMIC_RELAX_NONE); >>>> - plane_check_current_state(plane_old, ATOMIC_RELAX_NONE); >>>> - >>>> - /* Re-enable the plane through the legacy CRTC/primary- >>>> plane >>>> API, and >>>> - * verify through atomic. */ >>>> - crtc_commit_legacy(crtc, plane_old, CRTC_RELAX_MODE); >>>> + plane_get_current_state(primary, old_plane_values); >>>> + crtc_get_current_state(pipe_obj, old_crtc_values); >>>> + >>>> + igt_assert(!old_crtc_values[IGT_CRTC_MODE_ID]); >>>> + >>>> + igt_create_pattern_fb(pipe_obj->display->drm_fd, >>>> + mode->hdisplay, mode->vdisplay, >>>> + format, I915_TILING_NONE, &fb); >>>> + igt_plane_set_fb(primary, &fb); >>>> + igt_output_set_pipe(output, pipe_obj->pipe); >>>> + >>>> + igt_display_commit_atomic(pipe_obj->display, >>>> DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET, NULL); >>>> + >>>> + /* check the state, should still be old state */ >>>> + crtc_check_current_state(pipe_obj, old_crtc_values, >>>> old_plane_values, ATOMIC_RELAX_NONE); >>>> + plane_check_current_state(primary, old_plane_values, >>>> ATOMIC_RELAX_NONE); >>>> + >>>> + /* >>>> + * Enable the plane through the legacy CRTC/primary- >>>> plane >>>> API, and >>>> + * verify through atomic. >>>> + */ >>>> + crtc_commit(pipe_obj, primary, COMMIT_LEGACY, >>>> CRTC_RELAX_MODE); >>>> + >>>> + /* Same for disable.. */ >>>> + plane_get_current_state(primary, old_plane_values); >>>> + crtc_get_current_state(pipe_obj, old_crtc_values); >>>> + >>>> + igt_plane_set_fb(primary, NULL); >>>> + igt_output_set_pipe(output, PIPE_NONE); >>>> + >>>> + igt_display_commit_atomic(pipe_obj->display, >>>> DRM_MODE_ATOMIC_TEST_ONLY | DRM_MODE_ATOMIC_ALLOW_MODESET, NULL); >>>> >>>> - drmModeAtomicFree(req); >>>> + /* for extra stress, go through dpms off/on cycle */ >>>> + set_dpms(output, DRM_MODE_DPMS_OFF); >>>> + set_dpms(output, DRM_MODE_DPMS_ON); >>> There is this library function 'kmstest_set_connector_dpms()'. >>> Could we >>> utilize this function here instead? >> Sure, I never understood what the dpms call was supposed to expose >> though.. >> >> Want me to resend or is replacing the call with >> kmstest_set_connector_dpms(s, output->config.connector, >> DRM_MODE_DPMS_OFF); enough? > Well, my point of view is that we should use library functions as much > as possible. I guess that's the reason why we have the libraries in the > first place. So a vote for a replacement. > Thanks for review and irc r-b with fixes, pushed. :)
_______________________________________________ Intel-gfx mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/intel-gfx
