mirror of
https://github.com/Ryujinx/SDL.git
synced 2024-12-24 05:35:30 +00:00
kmsdrm: Moved to the ATOMIC KMS/DRM interface for buffer swapping, leaving DRM-legacy behind.
This commit is contained in:
parent
e410b34f92
commit
1a5503ce9f
|
@ -437,6 +437,13 @@ SDL_EGL_LoadLibraryOnly(_THIS, const char *egl_path)
|
||||||
LOAD_FUNC(eglGetError);
|
LOAD_FUNC(eglGetError);
|
||||||
LOAD_FUNC_EGLEXT(eglQueryDevicesEXT);
|
LOAD_FUNC_EGLEXT(eglQueryDevicesEXT);
|
||||||
LOAD_FUNC_EGLEXT(eglGetPlatformDisplayEXT);
|
LOAD_FUNC_EGLEXT(eglGetPlatformDisplayEXT);
|
||||||
|
/* Atomic functions */
|
||||||
|
LOAD_FUNC_EGLEXT(eglCreateSyncKHR);
|
||||||
|
LOAD_FUNC_EGLEXT(eglDestroySyncKHR);
|
||||||
|
LOAD_FUNC_EGLEXT(eglDupNativeFenceFDANDROID);
|
||||||
|
LOAD_FUNC_EGLEXT(eglWaitSyncKHR);
|
||||||
|
LOAD_FUNC_EGLEXT(eglClientWaitSyncKHR);
|
||||||
|
/* Atomic functions end */
|
||||||
|
|
||||||
if (path) {
|
if (path) {
|
||||||
SDL_strlcpy(_this->gl_config.driver_path, path, sizeof(_this->gl_config.driver_path) - 1);
|
SDL_strlcpy(_this->gl_config.driver_path, path, sizeof(_this->gl_config.driver_path) - 1);
|
||||||
|
|
|
@ -101,6 +101,21 @@ typedef struct SDL_EGL_VideoData
|
||||||
void **devices,
|
void **devices,
|
||||||
EGLint *num_devices);
|
EGLint *num_devices);
|
||||||
|
|
||||||
|
/* Atomic functions */
|
||||||
|
|
||||||
|
EGLSyncKHR(EGLAPIENTRY *eglCreateSyncKHR)(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list);
|
||||||
|
|
||||||
|
EGLBoolean(EGLAPIENTRY *eglDestroySyncKHR)(EGLDisplay dpy, EGLSyncKHR sync);
|
||||||
|
|
||||||
|
EGLint(EGLAPIENTRY *eglDupNativeFenceFDANDROID)(EGLDisplay dpy, EGLSyncKHR sync);
|
||||||
|
|
||||||
|
EGLint(EGLAPIENTRY *eglWaitSyncKHR)(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags);
|
||||||
|
|
||||||
|
EGLint(EGLAPIENTRY *eglClientWaitSyncKHR)(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout);
|
||||||
|
|
||||||
|
/* Atomic functions end */
|
||||||
|
|
||||||
|
|
||||||
/* whether EGL display was offscreen */
|
/* whether EGL display was offscreen */
|
||||||
int is_offscreen;
|
int is_offscreen;
|
||||||
|
|
||||||
|
|
|
@ -55,177 +55,125 @@ int KMSDRM_GLES_SetSwapInterval(_THIS, int interval) {
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/*********************************/
|
||||||
|
/* Atomic functions block */
|
||||||
|
/*********************************/
|
||||||
|
|
||||||
|
#define VOID2U64(x) ((uint64_t)(unsigned long)(x))
|
||||||
|
|
||||||
|
static EGLSyncKHR create_fence(int fd, _THIS)
|
||||||
|
{
|
||||||
|
EGLint attrib_list[] = {
|
||||||
|
EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fd,
|
||||||
|
EGL_NONE,
|
||||||
|
};
|
||||||
|
EGLSyncKHR fence = _this->egl_data->eglCreateSyncKHR(_this->egl_data->egl_display,
|
||||||
|
EGL_SYNC_NATIVE_FENCE_ANDROID, attrib_list);
|
||||||
|
assert(fence);
|
||||||
|
return fence;
|
||||||
|
}
|
||||||
|
|
||||||
int
|
int
|
||||||
KMSDRM_GLES_SwapWindow(_THIS, SDL_Window * window) {
|
KMSDRM_GLES_SwapWindow(_THIS, SDL_Window * window) {
|
||||||
|
|
||||||
SDL_WindowData *windata = ((SDL_WindowData *) window->driverdata);
|
SDL_WindowData *windata = ((SDL_WindowData *) window->driverdata);
|
||||||
SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
|
SDL_DisplayData *dispdata = (SDL_DisplayData *) SDL_GetDisplayForWindow(window)->driverdata;
|
||||||
SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
|
KMSDRM_FBInfo *fb;
|
||||||
KMSDRM_FBInfo *fb_info;
|
int ret;
|
||||||
|
|
||||||
/* ALWAYS wait for each pageflip to complete before issuing another, vsync or not,
|
uint32_t flags = DRM_MODE_ATOMIC_NONBLOCK;
|
||||||
or drmModePageFlip() will start returning EBUSY if there are pending pageflips.
|
|
||||||
|
|
||||||
To disable vsync in games, it would be needed to issue async pageflips,
|
EGLSyncKHR gpu_fence = NULL; /* out-fence from gpu, in-fence to kms */
|
||||||
and then wait for each pageflip to complete. Since async pageflips complete ASAP
|
EGLSyncKHR kms_fence = NULL; /* in-fence to gpu, out-fence from kms */
|
||||||
instead of VBLANK, thats how non-vsync screen updates should wok.
|
|
||||||
|
|
||||||
BUT Async pageflips do not work right now because calling drmModePageFlip() with the
|
/* Allow modeset (which is done inside atomic_commit). */
|
||||||
DRM_MODE_PAGE_FLIP_ASYNC flag returns error on every driver I have tried.
|
flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
|
||||||
|
|
||||||
So, for now, only do vsynced updates: _this->egl_data->egl_swapinterval is
|
if (dispdata->kms_out_fence_fd != -1) {
|
||||||
ignored for now, it makes no sense to use it until async pageflips work on drm drivers. */
|
kms_fence = create_fence(dispdata->kms_out_fence_fd, _this);
|
||||||
|
assert(kms_fence);
|
||||||
|
|
||||||
/* Recreate the GBM / EGL surfaces if the display mode has changed */
|
/* driver now has ownership of the fence fd: */
|
||||||
if (windata->egl_surface_dirty) {
|
dispdata->kms_out_fence_fd = -1;
|
||||||
KMSDRM_CreateSurfaces(_this, window);
|
|
||||||
}
|
|
||||||
|
|
||||||
if (windata->double_buffer) {
|
/* wait "on the gpu" (ie. this won't necessarily block, but
|
||||||
/* Use a double buffering scheme, independently of the number of buffers that the GBM surface has,
|
* will block the rendering until fence is signaled), until
|
||||||
(number of buffers on the GBM surface depends on the implementation).
|
* the previous pageflip completes so we don't render into
|
||||||
Double buffering (instead of triple) is achieved by waiting for synchronous pageflip to complete
|
* the buffer that is still on screen.
|
||||||
inmediately after the pageflip is issued. That way, in the end of this function only two buffers
|
|
||||||
are needed: a buffer that is available to be picked again by EGL as a backbuffer to draw on it,
|
|
||||||
and the new front buffer that has just been set up.
|
|
||||||
|
|
||||||
Since programmer has no control over the number of buffers of the GBM surface, wait for pageflip
|
|
||||||
is done inmediately after issuing pageflip, and so a double-buffer scheme is achieved. */
|
|
||||||
|
|
||||||
/* Ask EGL to mark the current back buffer to become the next front buffer.
|
|
||||||
That will happen when a pageflip is issued, and the next vsync arrives (sync flip)
|
|
||||||
or ASAP (async flip). */
|
|
||||||
if (!(_this->egl_data->eglSwapBuffers(_this->egl_data->egl_display, windata->egl_surface))) {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "eglSwapBuffers failed.");
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Get a handler to the buffer that is marked to become the next front buffer, and lock it
|
|
||||||
so it can not be chosen by EGL as a back buffer. */
|
|
||||||
windata->next_bo = KMSDRM_gbm_surface_lock_front_buffer(windata->gs);
|
|
||||||
if (!windata->next_bo) {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not lock GBM surface front buffer");
|
|
||||||
return 0;
|
|
||||||
/* } else {
|
|
||||||
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Locked GBM surface %p", (void *)windata->next_bo); */
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Issue synchronous pageflip: drmModePageFlip() NEVER blocks, synchronous here means that it
|
|
||||||
will be done on next VBLANK, not ASAP. And return to program loop inmediately. */
|
|
||||||
|
|
||||||
fb_info = KMSDRM_FBFromBO(_this, windata->next_bo);
|
|
||||||
if (!fb_info) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* When needed, this is done once we have the needed fb_id, not before. */
|
|
||||||
if (windata->crtc_setup_pending) {
|
|
||||||
if (KMSDRM_drmModeSetCrtc(viddata->drm_fd, dispdata->crtc_id, fb_info->fb_id, 0,
|
|
||||||
0, &dispdata->conn->connector_id, 1, &dispdata->mode)) {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not configure CRTC on video mode setting.");
|
|
||||||
}
|
|
||||||
windata->crtc_setup_pending = SDL_FALSE;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (!KMSDRM_drmModePageFlip(viddata->drm_fd, dispdata->crtc_id, fb_info->fb_id,
|
|
||||||
DRM_MODE_PAGE_FLIP_EVENT, &windata->waiting_for_flip)) {
|
|
||||||
windata->waiting_for_flip = SDL_TRUE;
|
|
||||||
} else {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not issue pageflip");
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Since issued pageflips are always synchronous (ASYNC dont currently work), these pageflips
|
|
||||||
will happen at next vsync, so in practice waiting for vsync is being done here. */
|
|
||||||
if (!KMSDRM_WaitPageFlip(_this, windata, -1)) {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Error waiting for pageflip event");
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Return the previous front buffer to the available buffer pool of the GBM surface,
|
|
||||||
so it can be chosen again by EGL as the back buffer for drawing into it. */
|
|
||||||
if (windata->curr_bo) {
|
|
||||||
KMSDRM_gbm_surface_release_buffer(windata->gs, windata->curr_bo);
|
|
||||||
/* SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Released GBM surface buffer %p", (void *)windata->curr_bo); */
|
|
||||||
windata->curr_bo = NULL;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Take note of the current front buffer, so it can be freed next time this function is called. */
|
|
||||||
windata->curr_bo = windata->next_bo;
|
|
||||||
} else {
|
|
||||||
/* Triple buffering requires waiting for last pageflip upon entering instead of waiting at the end,
|
|
||||||
and issuing the next pageflip at the end, thus allowing the program loop to run
|
|
||||||
while the issued pageflip arrives (at next VBLANK, since ONLY synchronous pageflips are possible).
|
|
||||||
In a game context, this means that the player can be doing inputs before seeing the last
|
|
||||||
completed frame, causing "input lag" that is known to plage other APIs and backends.
|
|
||||||
Triple buffering requires the use of three different buffers at the end of this function:
|
|
||||||
1- the front buffer which is on screen,
|
|
||||||
2- the back buffer wich is ready to be flipped (a pageflip has been issued on it, which has yet to complete)
|
|
||||||
3- a third buffer that can be used by EGL to draw while the previously issued pageflip arrives
|
|
||||||
(should not put back the previous front buffer into the free buffers pool of the
|
|
||||||
GBM surface until that happens).
|
|
||||||
If the implementation only has two buffers for the GBM surface, this would behave like a double buffer.
|
|
||||||
*/
|
*/
|
||||||
|
_this->egl_data->eglWaitSyncKHR(_this->egl_data->egl_display, kms_fence, 0);
|
||||||
/* Wait for previously issued pageflip to complete. */
|
|
||||||
if (!KMSDRM_WaitPageFlip(_this, windata, -1)) {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Error waiting for pageflip event");
|
|
||||||
return 0;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Free the previous front buffer so EGL can pick it again as back buffer.*/
|
/* insert fence to be singled in cmdstream.. this fence will be
|
||||||
|
* signaled when gpu rendering done
|
||||||
|
*/
|
||||||
|
gpu_fence = create_fence(EGL_NO_NATIVE_FENCE_FD_ANDROID, _this);
|
||||||
|
assert(gpu_fence);
|
||||||
|
|
||||||
|
_this->egl_data->eglSwapBuffers(_this->egl_data->egl_display, windata->egl_surface);
|
||||||
|
|
||||||
|
/* after swapbuffers, gpu_fence should be flushed, so safe to get the fd: */
|
||||||
|
dispdata->kms_in_fence_fd = _this->egl_data->eglDupNativeFenceFDANDROID(_this->egl_data->egl_display, gpu_fence);
|
||||||
|
_this->egl_data->eglDestroySyncKHR(_this->egl_data->egl_display, gpu_fence);
|
||||||
|
assert(dispdata->kms_in_fence_fd != -1);
|
||||||
|
|
||||||
|
windata->next_bo = KMSDRM_gbm_surface_lock_front_buffer(windata->gs);
|
||||||
|
if (!windata->next_bo) {
|
||||||
|
printf("Failed to lock frontbuffer\n");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
fb = KMSDRM_FBFromBO(_this, windata->next_bo);
|
||||||
|
if (!fb) {
|
||||||
|
printf("Failed to get a new framebuffer BO\n");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (kms_fence) {
|
||||||
|
EGLint status;
|
||||||
|
|
||||||
|
/* Wait on the CPU side for the _previous_ commit to
|
||||||
|
* complete before we post the flip through KMS, as
|
||||||
|
* atomic will reject the commit if we post a new one
|
||||||
|
* whilst the previous one is still pending.
|
||||||
|
*/
|
||||||
|
do {
|
||||||
|
status = _this->egl_data->eglClientWaitSyncKHR(_this->egl_data->egl_display,
|
||||||
|
kms_fence,
|
||||||
|
0,
|
||||||
|
EGL_FOREVER_KHR);
|
||||||
|
} while (status != EGL_CONDITION_SATISFIED_KHR);
|
||||||
|
|
||||||
|
_this->egl_data->eglDestroySyncKHR(_this->egl_data->egl_display, kms_fence);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Here you could also update drm plane layers if you want
|
||||||
|
* hw composition
|
||||||
|
*/
|
||||||
|
ret = drm_atomic_commit(_this, fb->fb_id, flags);
|
||||||
|
if (ret) {
|
||||||
|
printf("failed to do atomic commit\n");
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* release last buffer to render on again: */
|
||||||
if (windata->curr_bo) {
|
if (windata->curr_bo) {
|
||||||
KMSDRM_gbm_surface_release_buffer(windata->gs, windata->curr_bo);
|
KMSDRM_gbm_surface_release_buffer(windata->gs, windata->curr_bo);
|
||||||
/* SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Released GBM surface buffer %p", (void *)windata->curr_bo); */
|
|
||||||
windata->curr_bo = NULL;
|
windata->curr_bo = NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Ask EGL to mark the current back buffer to become the next front buffer.
|
|
||||||
That will happen when a pageflip is issued, and the next vsync arrives (sync flip)
|
|
||||||
or ASAP (async flip). */
|
|
||||||
if (!(_this->egl_data->eglSwapBuffers(_this->egl_data->egl_display, windata->egl_surface))) {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "eglSwapBuffers failed.");
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Take note of the current front buffer, so it can be freed next time this function is called. */
|
/* Take note of the current front buffer, so it can be freed next time this function is called. */
|
||||||
windata->curr_bo = windata->next_bo;
|
windata->curr_bo = windata->next_bo;
|
||||||
|
|
||||||
/* Get a handler to the buffer that is marked to become the next front buffer, and lock it
|
/* Allow a modeset change for the first commit only. */
|
||||||
so it can not be chosen by EGL as a back buffer. */
|
flags &= ~(DRM_MODE_ATOMIC_ALLOW_MODESET);
|
||||||
windata->next_bo = KMSDRM_gbm_surface_lock_front_buffer(windata->gs);
|
|
||||||
if (!windata->next_bo) {
|
return ret;
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not lock GBM surface front buffer");
|
|
||||||
return 0;
|
|
||||||
/* } else {
|
|
||||||
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Locked GBM surface %p", (void *)windata->next_bo); */
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Issue synchronous pageflip: drmModePageFlip() NEVER blocks, synchronous here means that it
|
/***************************************/
|
||||||
will be done on next VBLANK, not ASAP. And return to program loop inmediately. */
|
/* End of Atomic functions block */
|
||||||
fb_info = KMSDRM_FBFromBO(_this, windata->next_bo);
|
/***************************************/
|
||||||
if (!fb_info) {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* When needed, this is done once we have the needed fb_id, not before. */
|
|
||||||
if (windata->crtc_setup_pending) {
|
|
||||||
if (KMSDRM_drmModeSetCrtc(viddata->drm_fd, dispdata->crtc_id, fb_info->fb_id, 0,
|
|
||||||
0, &dispdata->conn->connector_id, 1, &dispdata->mode)) {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not configure CRTC on video mode setting.");
|
|
||||||
}
|
|
||||||
windata->crtc_setup_pending = SDL_FALSE;
|
|
||||||
}
|
|
||||||
|
|
||||||
|
|
||||||
if (!KMSDRM_drmModePageFlip(viddata->drm_fd, dispdata->crtc_id, fb_info->fb_id,
|
|
||||||
DRM_MODE_PAGE_FLIP_EVENT, &windata->waiting_for_flip)) {
|
|
||||||
windata->waiting_for_flip = SDL_TRUE;
|
|
||||||
} else {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "Could not issue pageflip");
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
SDL_EGL_MakeCurrent_impl(KMSDRM)
|
SDL_EGL_MakeCurrent_impl(KMSDRM)
|
||||||
|
|
||||||
|
|
|
@ -64,6 +64,27 @@ SDL_KMSDRM_SYM(int,drmModePageFlip,(int fd, uint32_t crtc_id, uint32_t fb_id,
|
||||||
uint32_t flags, void *user_data))
|
uint32_t flags, void *user_data))
|
||||||
|
|
||||||
|
|
||||||
|
/* Atomic functions */
|
||||||
|
|
||||||
|
SDL_KMSDRM_SYM(int,drmSetClientCap,(int fd, uint64_t capability, uint64_t value))
|
||||||
|
SDL_KMSDRM_SYM(drmModePlaneResPtr,drmModeGetPlaneResources,(int fd))
|
||||||
|
SDL_KMSDRM_SYM(drmModePlanePtr,drmModeGetPlane,(int fd, uint32_t plane_id))
|
||||||
|
SDL_KMSDRM_SYM(drmModeObjectPropertiesPtr,drmModeObjectGetProperties,(int fd,uint32_t object_id,uint32_t object_type))
|
||||||
|
SDL_KMSDRM_SYM(drmModePropertyPtr,drmModeGetProperty,(int fd, uint32_t propertyId))
|
||||||
|
|
||||||
|
SDL_KMSDRM_SYM(void,drmModeFreeProperty,(drmModePropertyPtr ptr))
|
||||||
|
SDL_KMSDRM_SYM(void,drmModeFreeObjectProperties,(drmModeObjectPropertiesPtr ptr))
|
||||||
|
SDL_KMSDRM_SYM(void,drmModeFreePlane,(drmModePlanePtr ptr))
|
||||||
|
SDL_KMSDRM_SYM(void,drmModeFreePlaneResources,(drmModePlaneResPtr ptr))
|
||||||
|
|
||||||
|
SDL_KMSDRM_SYM(drmModeAtomicReqPtr,drmModeAtomicAlloc,(void))
|
||||||
|
SDL_KMSDRM_SYM(void,drmModeAtomicFree,(drmModeAtomicReqPtr req))
|
||||||
|
SDL_KMSDRM_SYM(int,drmModeAtomicCommit,(int fd,drmModeAtomicReqPtr req,uint32_t flags,void *user_data))
|
||||||
|
SDL_KMSDRM_SYM(int,drmModeAtomicAddProperty,(drmModeAtomicReqPtr req,uint32_t object_id,uint32_t property_id,uint64_t value))
|
||||||
|
SDL_KMSDRM_SYM(int,drmModeCreatePropertyBlob,(int fd,const void *data,size_t size,uint32_t *id))
|
||||||
|
|
||||||
|
/* End of atomic fns */
|
||||||
|
|
||||||
SDL_KMSDRM_MODULE(GBM)
|
SDL_KMSDRM_MODULE(GBM)
|
||||||
SDL_KMSDRM_SYM(int,gbm_device_get_fd,(struct gbm_device *gbm))
|
SDL_KMSDRM_SYM(int,gbm_device_get_fd,(struct gbm_device *gbm))
|
||||||
SDL_KMSDRM_SYM(int,gbm_device_is_format_supported,(struct gbm_device *gbm,
|
SDL_KMSDRM_SYM(int,gbm_device_is_format_supported,(struct gbm_device *gbm,
|
||||||
|
|
|
@ -144,6 +144,320 @@ get_driindex(void)
|
||||||
return -ENOENT;
|
return -ENOENT;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/*********************************/
|
||||||
|
/* Atomic helper functions block */
|
||||||
|
/*********************************/
|
||||||
|
|
||||||
|
#define VOID2U64(x) ((uint64_t)(unsigned long)(x))
|
||||||
|
|
||||||
|
static int add_connector_property(drmModeAtomicReq *req, uint32_t obj_id,
|
||||||
|
const char *name, uint64_t value)
|
||||||
|
{
|
||||||
|
SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
|
||||||
|
unsigned int i;
|
||||||
|
int prop_id = 0;
|
||||||
|
|
||||||
|
for (i = 0 ; i < dispdata->connector_props->count_props ; i++) {
|
||||||
|
if (strcmp(dispdata->connector_props_info[i]->name, name) == 0) {
|
||||||
|
prop_id = dispdata->connector_props_info[i]->prop_id;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (prop_id < 0) {
|
||||||
|
printf("no connector property: %s\n", name);
|
||||||
|
return -EINVAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return KMSDRM_drmModeAtomicAddProperty(req, obj_id, prop_id, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int add_crtc_property(drmModeAtomicReq *req, uint32_t obj_id,
|
||||||
|
const char *name, uint64_t value)
|
||||||
|
{
|
||||||
|
SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
|
||||||
|
unsigned int i;
|
||||||
|
int prop_id = -1;
|
||||||
|
|
||||||
|
for (i = 0 ; i < dispdata->crtc_props->count_props ; i++) {
|
||||||
|
if (strcmp(dispdata->crtc_props_info[i]->name, name) == 0) {
|
||||||
|
prop_id = dispdata->crtc_props_info[i]->prop_id;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (prop_id < 0) {
|
||||||
|
printf("no crtc property: %s\n", name);
|
||||||
|
return -EINVAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return KMSDRM_drmModeAtomicAddProperty(req, obj_id, prop_id, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
static int add_plane_property(drmModeAtomicReq *req, uint32_t obj_id,
|
||||||
|
const char *name, uint64_t value)
|
||||||
|
{
|
||||||
|
SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
|
||||||
|
unsigned int i;
|
||||||
|
int prop_id = -1;
|
||||||
|
|
||||||
|
for (i = 0 ; i < dispdata->plane_props->count_props ; i++) {
|
||||||
|
if (strcmp(dispdata->plane_props_info[i]->name, name) == 0) {
|
||||||
|
prop_id = dispdata->plane_props_info[i]->prop_id;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (prop_id < 0) {
|
||||||
|
printf("no plane property: %s\n", name);
|
||||||
|
return -EINVAL;
|
||||||
|
}
|
||||||
|
|
||||||
|
return KMSDRM_drmModeAtomicAddProperty(req, obj_id, prop_id, value);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*static void get_plane_properties() {
|
||||||
|
uint32_t i;
|
||||||
|
dispdata->plane_ = drmModeObjectGetProperties(viddata->drm_fd,
|
||||||
|
plane->plane_id, DRM_MODE_OBJECT_PLANE);
|
||||||
|
|
||||||
|
if (!dispdata->type.props) {
|
||||||
|
printf("could not get %s %u properties: %s\n",
|
||||||
|
#type, id, strerror(errno));
|
||||||
|
return NULL;
|
||||||
|
}
|
||||||
|
|
||||||
|
dispdata->type->props_info = calloc(dispdata->type.props->count_props,
|
||||||
|
sizeof(*dispdata->type->props_info));
|
||||||
|
for (i = 0; i < dispdata->type->props->count_props; i++) {
|
||||||
|
dispdata->type.props_info[i] = drmModeGetProperty(viddata->drm_fd,
|
||||||
|
dispdata->type->props->props[i]);
|
||||||
|
}
|
||||||
|
return props;
|
||||||
|
}*/
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
void print_plane_info(_THIS, drmModePlanePtr plane)
|
||||||
|
{
|
||||||
|
char *plane_type;
|
||||||
|
drmModeRes *resources;
|
||||||
|
uint32_t type = 0;
|
||||||
|
SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
|
||||||
|
|
||||||
|
drmModeObjectPropertiesPtr props = KMSDRM_drmModeObjectGetProperties(viddata->drm_fd,
|
||||||
|
plane->plane_id, DRM_MODE_OBJECT_PLANE);
|
||||||
|
|
||||||
|
/* Search the plane props for the plane type. */
|
||||||
|
for (int j = 0; j < props->count_props; j++) {
|
||||||
|
|
||||||
|
drmModePropertyPtr p = KMSDRM_drmModeGetProperty(viddata->drm_fd, props->props[j]);
|
||||||
|
|
||||||
|
if ((strcmp(p->name, "type") == 0)) {
|
||||||
|
type = props->prop_values[j];
|
||||||
|
}
|
||||||
|
|
||||||
|
KMSDRM_drmModeFreeProperty(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
switch (type) {
|
||||||
|
case DRM_PLANE_TYPE_OVERLAY:
|
||||||
|
plane_type = "overlay";
|
||||||
|
break;
|
||||||
|
|
||||||
|
case DRM_PLANE_TYPE_PRIMARY:
|
||||||
|
plane_type = "primary";
|
||||||
|
break;
|
||||||
|
|
||||||
|
case DRM_PLANE_TYPE_CURSOR:
|
||||||
|
plane_type = "cursor";
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* Remember that, to present a plane on screen, it has to be connected to a CRTC so the CRTC scans it,
|
||||||
|
scales it, etc... and presents it on screen. */
|
||||||
|
|
||||||
|
/* Now we look for the CRTCs supported by the plane. */
|
||||||
|
resources = KMSDRM_drmModeGetResources(viddata->drm_fd);
|
||||||
|
if (!resources)
|
||||||
|
return;
|
||||||
|
|
||||||
|
printf("--PLANE ID: %d\nPLANE TYPE: %s\nCRTC READING THIS PLANE: %d\nCRTCS SUPPORTED BY THIS PLANE: ", plane->plane_id, plane_type, plane->crtc_id);
|
||||||
|
for (int i = 0; i < resources->count_crtcs; i++) {
|
||||||
|
if (plane->possible_crtcs & (1 << i)) {
|
||||||
|
uint32_t crtc_id = resources->crtcs[i];
|
||||||
|
printf ("%d", crtc_id);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
printf ("\n\n");
|
||||||
|
}
|
||||||
|
|
||||||
|
void get_planes_info(_THIS)
|
||||||
|
{
|
||||||
|
drmModePlaneResPtr plane_resources;
|
||||||
|
uint32_t i;
|
||||||
|
|
||||||
|
SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
|
||||||
|
SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
|
||||||
|
|
||||||
|
plane_resources = KMSDRM_drmModeGetPlaneResources(viddata->drm_fd);
|
||||||
|
if (!plane_resources) {
|
||||||
|
printf("drmModeGetPlaneResources failed: %s\n", strerror(errno));
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
printf("--Number of planes found: %d-- \n", plane_resources->count_planes);
|
||||||
|
printf("--Usable CRTC that we have chosen: %d-- \n", dispdata->crtc->crtc_id);
|
||||||
|
|
||||||
|
/* Iterate on all the available planes. */
|
||||||
|
for (i = 0; (i < plane_resources->count_planes); i++) {
|
||||||
|
|
||||||
|
uint32_t plane_id = plane_resources->planes[i];
|
||||||
|
|
||||||
|
drmModePlanePtr plane = KMSDRM_drmModeGetPlane(viddata->drm_fd, plane_id);
|
||||||
|
if (!plane) {
|
||||||
|
printf("drmModeGetPlane(%u) failed: %s\n", plane_id, strerror(errno));
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Print plane info. */
|
||||||
|
print_plane_info(_this, plane);
|
||||||
|
KMSDRM_drmModeFreePlane(plane);
|
||||||
|
}
|
||||||
|
|
||||||
|
KMSDRM_drmModeFreePlaneResources(plane_resources);
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* Get a plane that is PRIMARY (there's no guarantee that we have overlays in all hardware!)
|
||||||
|
and can use the CRTC we have chosen. That's all. */
|
||||||
|
int get_plane_id(_THIS)
|
||||||
|
{
|
||||||
|
drmModePlaneResPtr plane_resources;
|
||||||
|
uint32_t i, j;
|
||||||
|
int ret = -EINVAL;
|
||||||
|
int found_primary = 0;
|
||||||
|
|
||||||
|
SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
|
||||||
|
SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
|
||||||
|
|
||||||
|
plane_resources = KMSDRM_drmModeGetPlaneResources(viddata->drm_fd);
|
||||||
|
if (!plane_resources) {
|
||||||
|
printf("drmModeGetPlaneResources failed: %s\n", strerror(errno));
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Iterate on all the available planes. */
|
||||||
|
for (i = 0; (i < plane_resources->count_planes) && !found_primary; i++) {
|
||||||
|
|
||||||
|
uint32_t plane_id = plane_resources->planes[i];
|
||||||
|
|
||||||
|
drmModePlanePtr plane = KMSDRM_drmModeGetPlane(viddata->drm_fd, plane_id);
|
||||||
|
if (!plane) {
|
||||||
|
printf("drmModeGetPlane(%u) failed: %s\n", plane_id, strerror(errno));
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
/* See if the current CRTC is available for this plane. */
|
||||||
|
if (plane->possible_crtcs & (1 << dispdata->crtc_index)) {
|
||||||
|
|
||||||
|
drmModeObjectPropertiesPtr props = KMSDRM_drmModeObjectGetProperties(viddata->drm_fd, plane_id, DRM_MODE_OBJECT_PLANE);
|
||||||
|
ret = plane_id;
|
||||||
|
|
||||||
|
/* Search the plane props, to see if it's a primary plane. */
|
||||||
|
for (j = 0; j < props->count_props; j++) {
|
||||||
|
|
||||||
|
drmModePropertyPtr p = KMSDRM_drmModeGetProperty(viddata->drm_fd, props->props[j]);
|
||||||
|
|
||||||
|
if ((strcmp(p->name, "type") == 0) &&
|
||||||
|
(props->prop_values[j] == DRM_PLANE_TYPE_PRIMARY)) {
|
||||||
|
/* found our primary plane, lets use that: */
|
||||||
|
found_primary = 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
KMSDRM_drmModeFreeProperty(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
KMSDRM_drmModeFreeObjectProperties(props);
|
||||||
|
}
|
||||||
|
|
||||||
|
KMSDRM_drmModeFreePlane(plane);
|
||||||
|
}
|
||||||
|
|
||||||
|
KMSDRM_drmModeFreePlaneResources(plane_resources);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
int drm_atomic_commit(_THIS, uint32_t fb_id, uint32_t flags)
|
||||||
|
{
|
||||||
|
SDL_DisplayData *dispdata = (SDL_DisplayData *)SDL_GetDisplayDriverData(0);
|
||||||
|
SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
|
||||||
|
uint32_t plane_id = dispdata->plane->plane_id;
|
||||||
|
uint32_t blob_id;
|
||||||
|
drmModeAtomicReq *req;
|
||||||
|
int ret;
|
||||||
|
|
||||||
|
req = KMSDRM_drmModeAtomicAlloc();
|
||||||
|
|
||||||
|
if (flags & DRM_MODE_ATOMIC_ALLOW_MODESET) {
|
||||||
|
if (add_connector_property(req, dispdata->connector->connector_id, "CRTC_ID",
|
||||||
|
dispdata->crtc_id) < 0)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
if (KMSDRM_drmModeCreatePropertyBlob(viddata->drm_fd, &dispdata->mode, sizeof(dispdata->mode),
|
||||||
|
&blob_id) != 0)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
if (add_crtc_property(req, dispdata->crtc_id, "MODE_ID", blob_id) < 0)
|
||||||
|
return -1;
|
||||||
|
|
||||||
|
if (add_crtc_property(req, dispdata->crtc_id, "ACTIVE", 1) < 0)
|
||||||
|
return -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
add_plane_property(req, plane_id, "FB_ID", fb_id);
|
||||||
|
add_plane_property(req, plane_id, "CRTC_ID", dispdata->crtc_id);
|
||||||
|
add_plane_property(req, plane_id, "SRC_X", 0);
|
||||||
|
add_plane_property(req, plane_id, "SRC_Y", 0);
|
||||||
|
add_plane_property(req, plane_id, "SRC_W", dispdata->mode.hdisplay << 16);
|
||||||
|
add_plane_property(req, plane_id, "SRC_H", dispdata->mode.vdisplay << 16);
|
||||||
|
add_plane_property(req, plane_id, "CRTC_X", 0);
|
||||||
|
add_plane_property(req, plane_id, "CRTC_Y", 0);
|
||||||
|
add_plane_property(req, plane_id, "CRTC_W", dispdata->mode.hdisplay);
|
||||||
|
add_plane_property(req, plane_id, "CRTC_H", dispdata->mode.vdisplay);
|
||||||
|
|
||||||
|
if (dispdata->kms_in_fence_fd != -1) {
|
||||||
|
add_crtc_property(req, dispdata->crtc_id, "OUT_FENCE_PTR",
|
||||||
|
VOID2U64(&dispdata->kms_out_fence_fd));
|
||||||
|
add_plane_property(req, plane_id, "IN_FENCE_FD", dispdata->kms_in_fence_fd);
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = KMSDRM_drmModeAtomicCommit(viddata->drm_fd, req, flags, NULL);
|
||||||
|
if (ret)
|
||||||
|
goto out;
|
||||||
|
|
||||||
|
if (dispdata->kms_in_fence_fd != -1) {
|
||||||
|
close(dispdata->kms_in_fence_fd);
|
||||||
|
dispdata->kms_in_fence_fd = -1;
|
||||||
|
}
|
||||||
|
|
||||||
|
out:
|
||||||
|
KMSDRM_drmModeAtomicFree(req);
|
||||||
|
|
||||||
|
return ret;
|
||||||
|
}
|
||||||
|
|
||||||
|
/***************************************/
|
||||||
|
/* End of Atomic helper functions block*/
|
||||||
|
/***************************************/
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
static int
|
static int
|
||||||
KMSDRM_Available(void)
|
KMSDRM_Available(void)
|
||||||
{
|
{
|
||||||
|
@ -319,60 +633,6 @@ KMSDRM_FBFromBO(_THIS, struct gbm_bo *bo)
|
||||||
return fb_info;
|
return fb_info;
|
||||||
}
|
}
|
||||||
|
|
||||||
static void
|
|
||||||
KMSDRM_FlipHandler(int fd, unsigned int frame, unsigned int sec, unsigned int usec, void *data)
|
|
||||||
{
|
|
||||||
/* If the data pointer received here is the same passed as the user_data in drmModePageFlip()
|
|
||||||
then this is the event handler for the pageflip that was issued on drmPageFlip(): got here
|
|
||||||
because of that precise page flip, the while loop gets broken here because of the right event.
|
|
||||||
This knowledge will allow handling different issued pageflips if sometime in the future
|
|
||||||
managing different CRTCs in SDL2 is needed, for example (synchronous pageflips happen on vblank
|
|
||||||
and vblank is a CRTC thing). */
|
|
||||||
*((SDL_bool *) data) = SDL_FALSE;
|
|
||||||
}
|
|
||||||
|
|
||||||
SDL_bool
|
|
||||||
KMSDRM_WaitPageFlip(_THIS, SDL_WindowData *windata, int timeout) {
|
|
||||||
SDL_VideoData *viddata = ((SDL_VideoData *)_this->driverdata);
|
|
||||||
drmEventContext ev = {0};
|
|
||||||
struct pollfd pfd = {0};
|
|
||||||
|
|
||||||
ev.version = DRM_EVENT_CONTEXT_VERSION;
|
|
||||||
ev.page_flip_handler = KMSDRM_FlipHandler;
|
|
||||||
|
|
||||||
pfd.fd = viddata->drm_fd;
|
|
||||||
pfd.events = POLLIN;
|
|
||||||
|
|
||||||
while (windata->waiting_for_flip) {
|
|
||||||
pfd.revents = 0;
|
|
||||||
|
|
||||||
if (poll(&pfd, 1, timeout) < 0) {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "DRM poll error");
|
|
||||||
return SDL_FALSE;
|
|
||||||
}
|
|
||||||
|
|
||||||
if (pfd.revents & (POLLHUP | POLLERR)) {
|
|
||||||
SDL_LogError(SDL_LOG_CATEGORY_VIDEO, "DRM poll hup or error");
|
|
||||||
return SDL_FALSE;
|
|
||||||
}
|
|
||||||
|
|
||||||
/* Is the fd readable? Thats enough to call drmHandleEvent() on it. */
|
|
||||||
if (pfd.revents & POLLIN) {
|
|
||||||
/* Page flip? ONLY if the event that made the fd readable (=POLLIN state)
|
|
||||||
is a page flip, will drmHandleEvent call page_flip_handler, which will break the loop.
|
|
||||||
The drmHandleEvent() and subsequent page_flip_handler calls are both synchronous (blocking),
|
|
||||||
nothing runs on a different thread, so no need to protect waiting_for_flip access with mutexes. */
|
|
||||||
KMSDRM_drmHandleEvent(viddata->drm_fd, &ev);
|
|
||||||
} else {
|
|
||||||
/* Timed out and page flip didn't happen */
|
|
||||||
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Dropping frame while waiting_for_flip");
|
|
||||||
return SDL_FALSE;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return SDL_TRUE;
|
|
||||||
}
|
|
||||||
|
|
||||||
/*****************************************************************************/
|
/*****************************************************************************/
|
||||||
/* SDL Video and Display initialization/handling functions */
|
/* SDL Video and Display initialization/handling functions */
|
||||||
/* _this is a SDL_VideoDevice * */
|
/* _this is a SDL_VideoDevice * */
|
||||||
|
@ -382,8 +642,6 @@ KMSDRM_DestroySurfaces(_THIS, SDL_Window * window)
|
||||||
{
|
{
|
||||||
SDL_WindowData *windata = (SDL_WindowData *)window->driverdata;
|
SDL_WindowData *windata = (SDL_WindowData *)window->driverdata;
|
||||||
|
|
||||||
KMSDRM_WaitPageFlip(_this, windata, -1);
|
|
||||||
|
|
||||||
if (windata->curr_bo) {
|
if (windata->curr_bo) {
|
||||||
KMSDRM_gbm_surface_release_buffer(windata->gs, windata->curr_bo);
|
KMSDRM_gbm_surface_release_buffer(windata->gs, windata->curr_bo);
|
||||||
windata->curr_bo = NULL;
|
windata->curr_bo = NULL;
|
||||||
|
@ -504,6 +762,7 @@ KMSDRM_VideoInit(_THIS)
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/* Iterate on the available connectors to find a connected connector. */
|
||||||
for (int i = 0; i < resources->count_connectors; i++) {
|
for (int i = 0; i < resources->count_connectors; i++) {
|
||||||
drmModeConnector *conn = KMSDRM_drmModeGetConnector(viddata->drm_fd, resources->connectors[i]);
|
drmModeConnector *conn = KMSDRM_drmModeGetConnector(viddata->drm_fd, resources->connectors[i]);
|
||||||
|
|
||||||
|
@ -514,14 +773,15 @@ KMSDRM_VideoInit(_THIS)
|
||||||
if (conn->connection == DRM_MODE_CONNECTED && conn->count_modes) {
|
if (conn->connection == DRM_MODE_CONNECTED && conn->count_modes) {
|
||||||
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found connector %d with %d modes.",
|
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found connector %d with %d modes.",
|
||||||
conn->connector_id, conn->count_modes);
|
conn->connector_id, conn->count_modes);
|
||||||
dispdata->conn = conn;
|
dispdata->connector = conn;
|
||||||
|
dispdata->connector_id = conn->connector_id;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
KMSDRM_drmModeFreeConnector(conn);
|
KMSDRM_drmModeFreeConnector(conn);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!dispdata->conn) {
|
if (!dispdata->connector) {
|
||||||
ret = SDL_SetError("No currently active connector found.");
|
ret = SDL_SetError("No currently active connector found.");
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
@ -534,7 +794,7 @@ KMSDRM_VideoInit(_THIS)
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (encoder->encoder_id == dispdata->conn->encoder_id) {
|
if (encoder->encoder_id == dispdata->connector->encoder_id) {
|
||||||
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found encoder %d.", encoder->encoder_id);
|
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found encoder %d.", encoder->encoder_id);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
@ -552,13 +812,13 @@ KMSDRM_VideoInit(_THIS)
|
||||||
continue;
|
continue;
|
||||||
}
|
}
|
||||||
|
|
||||||
for (j = 0; j < dispdata->conn->count_encoders; j++) {
|
for (j = 0; j < dispdata->connector->count_encoders; j++) {
|
||||||
if (dispdata->conn->encoders[j] == encoder->encoder_id) {
|
if (dispdata->connector->encoders[j] == encoder->encoder_id) {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (j != dispdata->conn->count_encoders) {
|
if (j != dispdata->connector->count_encoders) {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
@ -575,40 +835,62 @@ KMSDRM_VideoInit(_THIS)
|
||||||
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found encoder %d.", encoder->encoder_id);
|
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Found encoder %d.", encoder->encoder_id);
|
||||||
|
|
||||||
/* Try to find a CRTC connected to this encoder */
|
/* Try to find a CRTC connected to this encoder */
|
||||||
dispdata->saved_crtc = KMSDRM_drmModeGetCrtc(viddata->drm_fd, encoder->crtc_id);
|
dispdata->crtc = KMSDRM_drmModeGetCrtc(viddata->drm_fd, encoder->crtc_id);
|
||||||
|
|
||||||
if (!dispdata->saved_crtc) {
|
/* If no CRTC was connected to the encoder, find the first CRTC that is supported by the encoder, and use that. */
|
||||||
/* No CRTC was connected, find the first CRTC that can be connected */
|
if (!dispdata->crtc) {
|
||||||
for (int i = 0; i < resources->count_crtcs; i++) {
|
for (int i = 0; i < resources->count_crtcs; i++) {
|
||||||
if (encoder->possible_crtcs & (1 << i)) {
|
if (encoder->possible_crtcs & (1 << i)) {
|
||||||
encoder->crtc_id = resources->crtcs[i];
|
encoder->crtc_id = resources->crtcs[i];
|
||||||
dispdata->saved_crtc = KMSDRM_drmModeGetCrtc(viddata->drm_fd, encoder->crtc_id);
|
dispdata->crtc = KMSDRM_drmModeGetCrtc(viddata->drm_fd, encoder->crtc_id);
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
if (!dispdata->saved_crtc) {
|
if (!dispdata->crtc) {
|
||||||
ret = SDL_SetError("No CRTC found.");
|
ret = SDL_SetError("No CRTC found.");
|
||||||
goto cleanup;
|
goto cleanup;
|
||||||
}
|
}
|
||||||
|
|
||||||
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Saved crtc_id %u, fb_id %u, (%u,%u), %ux%u",
|
/* SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "Saved crtc_id %u, fb_id %u, (%u,%u), %ux%u",
|
||||||
dispdata->saved_crtc->crtc_id, dispdata->saved_crtc->buffer_id, dispdata->saved_crtc->x,
|
dispdata->crtc->crtc_id, dispdata->crtc->buffer_id, dispdata->crtc->x,
|
||||||
dispdata->saved_crtc->y, dispdata->saved_crtc->width, dispdata->saved_crtc->height);
|
dispdata->crtc->y, dispdata->crtc->width, dispdata->crtc->height);
|
||||||
|
*/
|
||||||
|
|
||||||
dispdata->crtc_id = encoder->crtc_id;
|
dispdata->crtc_id = dispdata->crtc->crtc_id;
|
||||||
|
dispdata->crtc = KMSDRM_drmModeGetCrtc(viddata->drm_fd, dispdata->crtc_id);
|
||||||
|
|
||||||
|
/****************/
|
||||||
|
/* Atomic block */
|
||||||
|
/****************/
|
||||||
|
|
||||||
|
/* Find crtc_index. It's used to find out if a plane supports a CRTC. */
|
||||||
|
/* TODO: include this in the get_plane_id() function somehow. */
|
||||||
|
for (int i = 0; i < resources->count_crtcs; i++) {
|
||||||
|
if (resources->crtcs[i] == dispdata->crtc_id) {
|
||||||
|
dispdata->crtc_index = i;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Initialize the fence fd: */
|
||||||
|
dispdata->kms_out_fence_fd = -1,
|
||||||
|
|
||||||
|
/*********************/
|
||||||
|
/* Atomic block ends */
|
||||||
|
/*********************/
|
||||||
|
|
||||||
/* Figure out the default mode to be set. If the current CRTC's mode isn't
|
/* Figure out the default mode to be set. If the current CRTC's mode isn't
|
||||||
valid, select the first mode supported by the connector
|
valid, select the first mode supported by the connector
|
||||||
|
|
||||||
FIXME find first mode that specifies DRM_MODE_TYPE_PREFERRED */
|
FIXME find first mode that specifies DRM_MODE_TYPE_PREFERRED */
|
||||||
dispdata->mode = dispdata->saved_crtc->mode;
|
dispdata->mode = dispdata->crtc->mode;
|
||||||
|
|
||||||
if (dispdata->saved_crtc->mode_valid == 0) {
|
if (dispdata->crtc->mode_valid == 0) {
|
||||||
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO,
|
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO,
|
||||||
"Current mode is invalid, selecting connector's mode #0.");
|
"Current mode is invalid, selecting connector's mode #0.");
|
||||||
dispdata->mode = dispdata->conn->modes[0];
|
dispdata->mode = dispdata->connector->modes[0];
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Setup the single display that's available */
|
/* Setup the single display that's available */
|
||||||
|
@ -620,15 +902,15 @@ KMSDRM_VideoInit(_THIS)
|
||||||
display.desktop_mode.format = SDL_PIXELFORMAT_ARGB8888;
|
display.desktop_mode.format = SDL_PIXELFORMAT_ARGB8888;
|
||||||
#else
|
#else
|
||||||
/* FIXME */
|
/* FIXME */
|
||||||
drmModeFB *fb = drmModeGetFB(viddata->drm_fd, dispdata->saved_crtc->buffer_id);
|
drmModeFB *fb = drmModeGetFB(viddata->drm_fd, dispdata->crtc->buffer_id);
|
||||||
display.desktop_mode.format = drmToSDLPixelFormat(fb->bpp, fb->depth);
|
display.desktop_mode.format = drmToSDLPixelFormat(fb->bpp, fb->depth);
|
||||||
drmModeFreeFB(fb);
|
drmModeFreeFB(fb);
|
||||||
#endif
|
#endif
|
||||||
|
|
||||||
/* DRM mode index for the desktop mode is needed to complete desktop mode init NOW,
|
/* DRM mode index for the desktop mode is needed to complete desktop mode init NOW,
|
||||||
so look for it in the DRM modes array. */
|
so look for it in the DRM modes array. */
|
||||||
for (int i = 0; i < dispdata->conn->count_modes; i++) {
|
for (int i = 0; i < dispdata->connector->count_modes; i++) {
|
||||||
if (!SDL_memcmp(dispdata->conn->modes + i, &dispdata->saved_crtc->mode, sizeof(drmModeModeInfo))) {
|
if (!SDL_memcmp(dispdata->connector->modes + i, &dispdata->crtc->mode, sizeof(drmModeModeInfo))) {
|
||||||
SDL_DisplayModeData *modedata = SDL_calloc(1, sizeof(SDL_DisplayModeData));
|
SDL_DisplayModeData *modedata = SDL_calloc(1, sizeof(SDL_DisplayModeData));
|
||||||
if (modedata) {
|
if (modedata) {
|
||||||
modedata->mode_index = i;
|
modedata->mode_index = i;
|
||||||
|
@ -641,6 +923,79 @@ KMSDRM_VideoInit(_THIS)
|
||||||
display.driverdata = dispdata;
|
display.driverdata = dispdata;
|
||||||
SDL_AddVideoDisplay(&display);
|
SDL_AddVideoDisplay(&display);
|
||||||
|
|
||||||
|
/****************/
|
||||||
|
/* Atomic block */
|
||||||
|
/****************/
|
||||||
|
|
||||||
|
ret = KMSDRM_drmSetClientCap(viddata->drm_fd, DRM_CLIENT_CAP_ATOMIC, 1);
|
||||||
|
if (ret) {
|
||||||
|
ret = SDL_SetError("no atomic modesetting support.");
|
||||||
|
goto cleanup;
|
||||||
|
}
|
||||||
|
|
||||||
|
ret = KMSDRM_drmSetClientCap(viddata->drm_fd, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
|
||||||
|
if (ret) {
|
||||||
|
ret = SDL_SetError("no universal planes support.");
|
||||||
|
goto cleanup;
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
dispdata->plane_id = get_plane_id(_this);
|
||||||
|
if (!dispdata->plane_id) {
|
||||||
|
ret = SDL_SetError("could not find a suitable plane.");
|
||||||
|
goto cleanup;
|
||||||
|
}
|
||||||
|
|
||||||
|
dispdata->plane = KMSDRM_drmModeGetPlane(viddata->drm_fd, dispdata->plane_id);
|
||||||
|
|
||||||
|
//get_planes_info(_this);
|
||||||
|
|
||||||
|
/* We only do single plane to single crtc to single connector, no
|
||||||
|
* fancy multi-monitor or multi-plane stuff. So just grab the
|
||||||
|
* plane/crtc/connector property info for one of each:
|
||||||
|
*/
|
||||||
|
|
||||||
|
/* Get PLANE properties */
|
||||||
|
dispdata->plane_props = KMSDRM_drmModeObjectGetProperties(viddata->drm_fd,
|
||||||
|
dispdata->plane_id, DRM_MODE_OBJECT_PLANE);
|
||||||
|
|
||||||
|
dispdata->plane_props_info = calloc(dispdata->plane_props->count_props,
|
||||||
|
sizeof(dispdata->plane_props_info));
|
||||||
|
|
||||||
|
for (int i = 0; i < dispdata->plane_props->count_props; i++) {
|
||||||
|
dispdata->plane_props_info[i] = KMSDRM_drmModeGetProperty(viddata->drm_fd,
|
||||||
|
dispdata->plane_props->props[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Get CRTC properties */
|
||||||
|
dispdata->crtc_props = KMSDRM_drmModeObjectGetProperties(viddata->drm_fd,
|
||||||
|
dispdata->crtc_id, DRM_MODE_OBJECT_CRTC);
|
||||||
|
|
||||||
|
dispdata->crtc_props_info = calloc(dispdata->crtc_props->count_props,
|
||||||
|
sizeof(dispdata->crtc_props_info));
|
||||||
|
|
||||||
|
for (int i = 0; i < dispdata->crtc_props->count_props; i++) {
|
||||||
|
dispdata->crtc_props_info[i] = KMSDRM_drmModeGetProperty(viddata->drm_fd,
|
||||||
|
dispdata->crtc_props->props[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Get connector properties */
|
||||||
|
dispdata->connector_props = KMSDRM_drmModeObjectGetProperties(viddata->drm_fd,
|
||||||
|
dispdata->connector_id, DRM_MODE_OBJECT_CONNECTOR);
|
||||||
|
|
||||||
|
dispdata->connector_props_info = calloc(dispdata->connector_props->count_props,
|
||||||
|
sizeof(dispdata->connector_props_info));
|
||||||
|
|
||||||
|
for (int i = 0; i < dispdata->connector_props->count_props; i++) {
|
||||||
|
dispdata->connector_props_info[i] = KMSDRM_drmModeGetProperty(viddata->drm_fd,
|
||||||
|
dispdata->connector_props->props[i]);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*********************/
|
||||||
|
/* Atomic block ends */
|
||||||
|
/*********************/
|
||||||
|
|
||||||
#ifdef SDL_INPUT_LINUXEV
|
#ifdef SDL_INPUT_LINUXEV
|
||||||
SDL_EVDEV_Init();
|
SDL_EVDEV_Init();
|
||||||
#endif
|
#endif
|
||||||
|
@ -657,13 +1012,13 @@ cleanup:
|
||||||
|
|
||||||
if (ret != 0) {
|
if (ret != 0) {
|
||||||
/* Error (complete) cleanup */
|
/* Error (complete) cleanup */
|
||||||
if (dispdata->conn) {
|
if (dispdata->connector) {
|
||||||
KMSDRM_drmModeFreeConnector(dispdata->conn);
|
KMSDRM_drmModeFreeConnector(dispdata->connector);
|
||||||
dispdata->conn = NULL;
|
dispdata->connector = NULL;
|
||||||
}
|
}
|
||||||
if (dispdata->saved_crtc) {
|
if (dispdata->crtc) {
|
||||||
KMSDRM_drmModeFreeCrtc(dispdata->saved_crtc);
|
KMSDRM_drmModeFreeCrtc(dispdata->crtc);
|
||||||
dispdata->saved_crtc = NULL;
|
dispdata->crtc = NULL;
|
||||||
}
|
}
|
||||||
if (viddata->gbm_dev) {
|
if (viddata->gbm_dev) {
|
||||||
KMSDRM_gbm_device_destroy(viddata->gbm_dev);
|
KMSDRM_gbm_device_destroy(viddata->gbm_dev);
|
||||||
|
@ -697,9 +1052,9 @@ KMSDRM_VideoQuit(_THIS)
|
||||||
viddata->num_windows = 0;
|
viddata->num_windows = 0;
|
||||||
|
|
||||||
/* Restore saved CRTC settings */
|
/* Restore saved CRTC settings */
|
||||||
if (viddata->drm_fd >= 0 && dispdata && dispdata->conn && dispdata->saved_crtc) {
|
if (viddata->drm_fd >= 0 && dispdata && dispdata->connector && dispdata->crtc) {
|
||||||
drmModeConnector *conn = dispdata->conn;
|
drmModeConnector *conn = dispdata->connector;
|
||||||
drmModeCrtc *crtc = dispdata->saved_crtc;
|
drmModeCrtc *crtc = dispdata->crtc;
|
||||||
|
|
||||||
int ret = KMSDRM_drmModeSetCrtc(viddata->drm_fd, crtc->crtc_id, crtc->buffer_id,
|
int ret = KMSDRM_drmModeSetCrtc(viddata->drm_fd, crtc->crtc_id, crtc->buffer_id,
|
||||||
crtc->x, crtc->y, &conn->connector_id, 1, &crtc->mode);
|
crtc->x, crtc->y, &conn->connector_id, 1, &crtc->mode);
|
||||||
|
@ -708,13 +1063,13 @@ KMSDRM_VideoQuit(_THIS)
|
||||||
SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "Could not restore original CRTC mode");
|
SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "Could not restore original CRTC mode");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
if (dispdata && dispdata->conn) {
|
if (dispdata && dispdata->connector) {
|
||||||
KMSDRM_drmModeFreeConnector(dispdata->conn);
|
KMSDRM_drmModeFreeConnector(dispdata->connector);
|
||||||
dispdata->conn = NULL;
|
dispdata->connector = NULL;
|
||||||
}
|
}
|
||||||
if (dispdata && dispdata->saved_crtc) {
|
if (dispdata && dispdata->crtc) {
|
||||||
KMSDRM_drmModeFreeCrtc(dispdata->saved_crtc);
|
KMSDRM_drmModeFreeCrtc(dispdata->crtc);
|
||||||
dispdata->saved_crtc = NULL;
|
dispdata->crtc = NULL;
|
||||||
}
|
}
|
||||||
if (viddata->gbm_dev) {
|
if (viddata->gbm_dev) {
|
||||||
KMSDRM_gbm_device_destroy(viddata->gbm_dev);
|
KMSDRM_gbm_device_destroy(viddata->gbm_dev);
|
||||||
|
@ -734,7 +1089,7 @@ void
|
||||||
KMSDRM_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
|
KMSDRM_GetDisplayModes(_THIS, SDL_VideoDisplay * display)
|
||||||
{
|
{
|
||||||
SDL_DisplayData *dispdata = display->driverdata;
|
SDL_DisplayData *dispdata = display->driverdata;
|
||||||
drmModeConnector *conn = dispdata->conn;
|
drmModeConnector *conn = dispdata->connector;
|
||||||
SDL_DisplayMode mode;
|
SDL_DisplayMode mode;
|
||||||
|
|
||||||
for (int i = 0; i < conn->count_modes; i++) {
|
for (int i = 0; i < conn->count_modes; i++) {
|
||||||
|
@ -762,7 +1117,7 @@ KMSDRM_SetDisplayMode(_THIS, SDL_VideoDisplay * display, SDL_DisplayMode * mode)
|
||||||
SDL_VideoData *viddata = (SDL_VideoData *)_this->driverdata;
|
SDL_VideoData *viddata = (SDL_VideoData *)_this->driverdata;
|
||||||
SDL_DisplayData *dispdata = (SDL_DisplayData *)display->driverdata;
|
SDL_DisplayData *dispdata = (SDL_DisplayData *)display->driverdata;
|
||||||
SDL_DisplayModeData *modedata = (SDL_DisplayModeData *)mode->driverdata;
|
SDL_DisplayModeData *modedata = (SDL_DisplayModeData *)mode->driverdata;
|
||||||
drmModeConnector *conn = dispdata->conn;
|
drmModeConnector *conn = dispdata->connector;
|
||||||
|
|
||||||
if (!modedata) {
|
if (!modedata) {
|
||||||
return SDL_SetError("Mode doesn't have an associated index");
|
return SDL_SetError("Mode doesn't have an associated index");
|
||||||
|
@ -808,7 +1163,6 @@ KMSDRM_CreateWindow(_THIS, SDL_Window * window)
|
||||||
}
|
}
|
||||||
|
|
||||||
/* Init windata fields. */
|
/* Init windata fields. */
|
||||||
windata->waiting_for_flip = SDL_FALSE;
|
|
||||||
windata->double_buffer = SDL_FALSE;
|
windata->double_buffer = SDL_FALSE;
|
||||||
windata->crtc_setup_pending = SDL_FALSE;
|
windata->crtc_setup_pending = SDL_FALSE;
|
||||||
windata->egl_surface_dirty = SDL_FALSE;
|
windata->egl_surface_dirty = SDL_FALSE;
|
||||||
|
|
|
@ -31,6 +31,7 @@
|
||||||
#include <xf86drm.h>
|
#include <xf86drm.h>
|
||||||
#include <xf86drmMode.h>
|
#include <xf86drmMode.h>
|
||||||
#include <gbm.h>
|
#include <gbm.h>
|
||||||
|
#include <assert.h>
|
||||||
#if SDL_VIDEO_OPENGL_EGL
|
#if SDL_VIDEO_OPENGL_EGL
|
||||||
#include <EGL/egl.h>
|
#include <EGL/egl.h>
|
||||||
#endif
|
#endif
|
||||||
|
@ -55,10 +56,28 @@ typedef struct SDL_DisplayModeData
|
||||||
|
|
||||||
typedef struct SDL_DisplayData
|
typedef struct SDL_DisplayData
|
||||||
{
|
{
|
||||||
uint32_t crtc_id;
|
|
||||||
drmModeConnector *conn;
|
|
||||||
drmModeModeInfo mode;
|
drmModeModeInfo mode;
|
||||||
drmModeCrtc *saved_crtc; /* CRTC to restore on quit */
|
uint32_t plane_id;
|
||||||
|
uint32_t crtc_id;
|
||||||
|
uint32_t connector_id;
|
||||||
|
|
||||||
|
drmModePlane *plane;
|
||||||
|
drmModeObjectProperties *plane_props;
|
||||||
|
drmModePropertyRes **plane_props_info;
|
||||||
|
|
||||||
|
drmModeCrtc *crtc;
|
||||||
|
drmModeObjectProperties *crtc_props;
|
||||||
|
drmModePropertyRes **crtc_props_info;
|
||||||
|
|
||||||
|
drmModeConnector *connector;
|
||||||
|
drmModeObjectProperties *connector_props;
|
||||||
|
drmModePropertyRes **connector_props_info;
|
||||||
|
|
||||||
|
int crtc_index;
|
||||||
|
int kms_in_fence_fd;
|
||||||
|
int kms_out_fence_fd;
|
||||||
|
|
||||||
} SDL_DisplayData;
|
} SDL_DisplayData;
|
||||||
|
|
||||||
|
|
||||||
|
@ -69,7 +88,6 @@ typedef struct SDL_WindowData
|
||||||
struct gbm_bo *curr_bo;
|
struct gbm_bo *curr_bo;
|
||||||
struct gbm_bo *next_bo;
|
struct gbm_bo *next_bo;
|
||||||
struct gbm_bo *crtc_bo;
|
struct gbm_bo *crtc_bo;
|
||||||
SDL_bool waiting_for_flip;
|
|
||||||
SDL_bool double_buffer;
|
SDL_bool double_buffer;
|
||||||
SDL_bool crtc_setup_pending;
|
SDL_bool crtc_setup_pending;
|
||||||
#if SDL_VIDEO_OPENGL_EGL
|
#if SDL_VIDEO_OPENGL_EGL
|
||||||
|
@ -89,6 +107,9 @@ int KMSDRM_CreateSurfaces(_THIS, SDL_Window * window);
|
||||||
KMSDRM_FBInfo *KMSDRM_FBFromBO(_THIS, struct gbm_bo *bo);
|
KMSDRM_FBInfo *KMSDRM_FBFromBO(_THIS, struct gbm_bo *bo);
|
||||||
SDL_bool KMSDRM_WaitPageFlip(_THIS, SDL_WindowData *windata, int timeout);
|
SDL_bool KMSDRM_WaitPageFlip(_THIS, SDL_WindowData *windata, int timeout);
|
||||||
|
|
||||||
|
/* Atomic functions that are used from SDL_kmsdrmopengles.c */
|
||||||
|
int drm_atomic_commit(_THIS, uint32_t fb_id, uint32_t flags);
|
||||||
|
|
||||||
/****************************************************************************/
|
/****************************************************************************/
|
||||||
/* SDL_VideoDevice functions declaration */
|
/* SDL_VideoDevice functions declaration */
|
||||||
/****************************************************************************/
|
/****************************************************************************/
|
||||||
|
|
Loading…
Reference in a new issue