summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMichel Dänzer <michel.daenzer@amd.com>2015-06-02 17:00:46 +0900
committerMichel Dänzer <michel@daenzer.net>2015-06-08 17:05:36 +0900
commitfafb8c6ac925ad16073e5a60dbf60d5add11bb25 (patch)
tree5a2e517721ac304218fcb5a046a7c3afda0f8ce6
parent5b51f0e7e396ea946ef85429a8e9be5c1d5c39c3 (diff)
Add support for the Present extension
-rw-r--r--configure.ac6
-rw-r--r--src/Makefile.am2
-rw-r--r--src/amdgpu_drv.h3
-rw-r--r--src/amdgpu_kms.c3
-rw-r--r--src/amdgpu_present.c394
5 files changed, 406 insertions, 2 deletions
diff --git a/configure.ac b/configure.ac
index 2d6d4c7..b91ce17 100644
--- a/configure.ac
+++ b/configure.ac
@@ -162,6 +162,12 @@ AC_CHECK_HEADERS([misyncshm.h], [], [],
#include <xorg-server.h>
#include <screenint.h>])
+AC_CHECK_HEADERS([present.h], [], [],
+ [#include <X11/Xmd.h>
+ #include <X11/Xproto.h>
+ #include <X11/X.h>
+ #include "xorg-server.h"])
+
CPPFLAGS="$SAVE_CPPFLAGS"
PKG_CHECK_MODULES([PCIACCESS], [pciaccess >= 0.8.0])
diff --git a/src/Makefile.am b/src/Makefile.am
index fa3be5c..fc8b77a 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -29,7 +29,7 @@
amdgpu_drv_la_LIBADD = $(PCIACCESS_LIBS) $(LIBDRM_AMDGPU_LIBS) $(GBM_LIBS)
AMDGPU_KMS_SRCS=amdgpu_bo_helper.c amdgpu_dri2.c amdgpu_drm_queue.c amdgpu_kms.c \
- amdgpu_sync.c drmmode_display.c
+ amdgpu_present.c amdgpu_sync.c drmmode_display.c
AM_CFLAGS = \
@GBM_CFLAGS@ \
diff --git a/src/amdgpu_drv.h b/src/amdgpu_drv.h
index ad51c86..c6c968f 100644
--- a/src/amdgpu_drv.h
+++ b/src/amdgpu_drv.h
@@ -233,6 +233,9 @@ typedef struct {
} AMDGPUInfoRec, *AMDGPUInfoPtr;
+/* amdgpu_present.c */
+Bool amdgpu_present_screen_init(ScreenPtr screen);
+
/* amdgpu_sync.c */
extern Bool amdgpu_sync_init(ScreenPtr screen);
extern void amdgpu_sync_close(ScreenPtr screen);
diff --git a/src/amdgpu_kms.c b/src/amdgpu_kms.c
index 28d9305..05e9adf 100644
--- a/src/amdgpu_kms.c
+++ b/src/amdgpu_kms.c
@@ -827,7 +827,8 @@ Bool AMDGPUScreenInit_KMS(SCREEN_INIT_ARGS_DECL)
}
#endif
- amdgpu_sync_init(pScreen);
+ if (amdgpu_sync_init(pScreen))
+ amdgpu_present_screen_init(pScreen);
pScrn->vtSema = TRUE;
xf86SetBackingStore(pScreen);
diff --git a/src/amdgpu_present.c b/src/amdgpu_present.c
new file mode 100644
index 0000000..c0a5a32
--- /dev/null
+++ b/src/amdgpu_present.c
@@ -0,0 +1,394 @@
+/*
+ * Copyright © 2014 Intel Corporation
+ * Copyright © 2015 Advanced Micro Devices, Inc.
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, provided that
+ * the above copyright notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting documentation, and
+ * that the name of the copyright holders not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission. The copyright holders make no representations
+ * about the suitability of this software for any purpose. It is provided "as
+ * is" without express or implied warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
+ * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+ * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+ * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+ * OF THIS SOFTWARE.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "amdgpu_drv.h"
+
+#ifdef HAVE_PRESENT_H
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <sys/time.h>
+#include <time.h>
+#include <errno.h>
+
+#include "amdgpu_glamor.h"
+#include "amdgpu_pixmap.h"
+#include "amdgpu_video.h"
+
+#include "present.h"
+
+struct amdgpu_present_vblank_event {
+ uint64_t event_id;
+};
+
+static uint32_t crtc_select(int crtc_id)
+{
+ if (crtc_id > 1)
+ return crtc_id << DRM_VBLANK_HIGH_CRTC_SHIFT;
+ else if (crtc_id > 0)
+ return DRM_VBLANK_SECONDARY;
+ else
+ return 0;
+}
+
+static RRCrtcPtr
+amdgpu_present_get_crtc(WindowPtr window)
+{
+ ScreenPtr screen = window->drawable.pScreen;
+ ScrnInfoPtr pScrn = xf86ScreenToScrn(screen);
+ xf86CrtcPtr crtc;
+ RRCrtcPtr randr_crtc = NULL;
+
+ crtc = amdgpu_pick_best_crtc(pScrn, FALSE,
+ window->drawable.x,
+ window->drawable.x + window->drawable.width,
+ window->drawable.y,
+ window->drawable.y + window->drawable.height);
+
+ /* Make sure the CRTC is valid and this is the real front buffer */
+ if (crtc != NULL && !crtc->rotatedData)
+ randr_crtc = crtc->randr_crtc;
+
+ return randr_crtc;
+}
+
+static int
+amdgpu_present_get_ust_msc(RRCrtcPtr crtc, CARD64 *ust, CARD64 *msc)
+{
+ return drmmode_crtc_get_ust_msc(crtc->devPrivate, ust, msc);
+}
+
+/*
+ * Flush the DRM event queue when full; this
+ * makes space for new requests
+ */
+static Bool
+amdgpu_present_flush_drm_events(ScreenPtr screen)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
+ xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(scrn);
+ drmmode_crtc_private_ptr drmmode_crtc = xf86_config->crtc[0]->driver_private;
+ drmmode_ptr drmmode = drmmode_crtc->drmmode;
+ struct pollfd p = { .fd = drmmode->fd, .events = POLLIN };
+ int r;
+
+ do {
+ r = poll(&p, 1, 0);
+ } while (r == -1 && (errno == EINTR || errno == EAGAIN));
+
+ if (r <= 0)
+ return 0;
+
+ return drmHandleEvent(drmmode->fd, &drmmode->event_context) >= 0;
+}
+
+/*
+ * Called when the queued vblank event has occurred
+ */
+static void
+amdgpu_present_vblank_handler(ScrnInfoPtr scrn, unsigned int msc,
+ uint64_t usec, void *data)
+{
+ struct amdgpu_present_vblank_event *event = data;
+
+ present_event_notify(event->event_id, usec, msc);
+ free(event);
+}
+
+/*
+ * Called when the queued vblank is aborted
+ */
+static void
+amdgpu_present_vblank_abort(ScrnInfoPtr scrn, void *data)
+{
+ struct amdgpu_present_vblank_event *event = data;
+
+ free(event);
+}
+
+/*
+ * Queue an event to report back to the Present extension when the specified
+ * MSC has past
+ */
+static int
+amdgpu_present_queue_vblank(RRCrtcPtr crtc, uint64_t event_id, uint64_t msc)
+{
+ xf86CrtcPtr xf86_crtc = crtc->devPrivate;
+ ScreenPtr screen = crtc->pScreen;
+ ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
+ AMDGPUInfoPtr info = AMDGPUPTR(scrn);
+ int crtc_id = drmmode_get_crtc_id(xf86_crtc);
+ struct amdgpu_present_vblank_event *event;
+ struct amdgpu_drm_queue_entry *queue;
+ drmVBlank vbl;
+ int ret;
+
+ event = calloc(sizeof(struct amdgpu_present_vblank_event), 1);
+ if (!event)
+ return BadAlloc;
+ event->event_id = event_id;
+ queue = amdgpu_drm_queue_alloc(scrn, AMDGPU_DRM_QUEUE_CLIENT_DEFAULT,
+ event_id, event,
+ amdgpu_present_vblank_handler,
+ amdgpu_present_vblank_abort);
+ if (!queue) {
+ free(event);
+ return BadAlloc;
+ }
+
+ vbl.request.type = DRM_VBLANK_ABSOLUTE | DRM_VBLANK_EVENT | crtc_select(crtc_id);
+ vbl.request.sequence = msc;
+ vbl.request.signal = (unsigned long)queue;
+ for (;;) {
+ ret = drmWaitVBlank(info->dri2.drm_fd, &vbl);
+ if (!ret)
+ break;
+ if (errno != EBUSY || !amdgpu_present_flush_drm_events(screen)) {
+ amdgpu_drm_abort_entry(queue);
+ return BadAlloc;
+ }
+ }
+
+ return Success;
+}
+
+/*
+ * Remove a pending vblank event from the DRM queue so that it is not reported
+ * to the extension
+ */
+static void
+amdgpu_present_abort_vblank(RRCrtcPtr crtc, uint64_t event_id, uint64_t msc)
+{
+ amdgpu_drm_abort_id(event_id);
+}
+
+/*
+ * Flush our batch buffer when requested by the Present extension.
+ */
+static void
+amdgpu_present_flush(WindowPtr window)
+{
+ amdgpu_glamor_flush(xf86ScreenToScrn(window->drawable.pScreen));
+}
+
+/*
+ * Test to see if page flipping is possible on the target crtc
+ */
+static Bool
+amdgpu_present_check_flip(RRCrtcPtr crtc, WindowPtr window, PixmapPtr pixmap,
+ Bool sync_flip)
+{
+ ScreenPtr screen = window->drawable.pScreen;
+ ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
+ AMDGPUInfoPtr info = AMDGPUPTR(scrn);
+
+ if (!scrn->vtSema)
+ return FALSE;
+
+ if (!info->allowPageFlip)
+ return FALSE;
+
+ if (!sync_flip)
+ return FALSE;
+
+ if (crtc) {
+ xf86CrtcPtr xf86_crtc = crtc->devPrivate;
+ drmmode_crtc_private_ptr drmmode_crtc = xf86_crtc->driver_private;
+
+ if (!drmmode_crtc ||
+ drmmode_crtc->rotate_buffer != NULL ||
+ drmmode_crtc->dpms_mode != DPMSModeOn)
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/*
+ * Once the flip has been completed on all CRTCs, notify the
+ * extension code telling it when that happened
+ */
+static void
+amdgpu_present_flip_event(ScrnInfoPtr scrn, uint32_t msc, uint64_t ust, void *pageflip_data)
+{
+ struct amdgpu_present_vblank_event *event = pageflip_data;
+
+ present_event_notify(event->event_id, ust, msc);
+ free(event);
+}
+
+/*
+ * The flip has been aborted, free the structure
+ */
+static void
+amdgpu_present_flip_abort(ScrnInfoPtr scrn, void *pageflip_data)
+{
+ struct amdgpu_present_vblank_event *event = pageflip_data;
+
+ free(event);
+}
+
+/*
+ * Queue a flip on 'crtc' to 'pixmap' at 'target_msc'. If 'sync_flip' is true,
+ * then wait for vblank. Otherwise, flip immediately
+ */
+static Bool
+amdgpu_present_flip(RRCrtcPtr crtc, uint64_t event_id, uint64_t target_msc,
+ PixmapPtr pixmap, Bool sync_flip)
+{
+ ScreenPtr screen = crtc->pScreen;
+ ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
+ struct amdgpu_present_vblank_event *event;
+ xf86CrtcPtr xf86_crtc = crtc->devPrivate;
+ int crtc_id = xf86_crtc ? drmmode_get_crtc_id(xf86_crtc) : -1;
+ struct amdgpu_buffer *bo;
+ Bool ret;
+
+ if (!amdgpu_present_check_flip(crtc, screen->root, pixmap, sync_flip))
+ return FALSE;
+
+ bo = amdgpu_get_pixmap_bo(pixmap);
+ if (!bo)
+ return FALSE;
+
+ event = calloc(1, sizeof(struct amdgpu_present_vblank_event));
+ if (!event)
+ return FALSE;
+
+ event->event_id = event_id;
+
+ ret = amdgpu_do_pageflip(scrn, AMDGPU_DRM_QUEUE_CLIENT_DEFAULT, bo,
+ event_id, event, crtc_id,
+ amdgpu_present_flip_event,
+ amdgpu_present_flip_abort);
+ if (!ret)
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR, "present flip failed\n");
+
+ return ret;
+}
+
+/*
+ * Queue a flip back to the normal frame buffer
+ */
+static void
+amdgpu_present_unflip(ScreenPtr screen, uint64_t event_id)
+{
+ ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
+ struct amdgpu_present_vblank_event *event;
+ PixmapPtr pixmap = screen->GetScreenPixmap(screen);
+ struct amdgpu_buffer *bo;
+ Bool ret;
+
+ if (!amdgpu_present_check_flip(NULL, screen->root, pixmap, TRUE))
+ return;
+
+ bo = amdgpu_get_pixmap_bo(pixmap);
+ if (!bo)
+ return;
+
+ event = calloc(1, sizeof(struct amdgpu_present_vblank_event));
+ if (!event)
+ return;
+
+ event->event_id = event_id;
+
+ ret = amdgpu_do_pageflip(scrn, AMDGPU_DRM_QUEUE_CLIENT_DEFAULT, bo,
+ event_id, event, -1, amdgpu_present_flip_event,
+ amdgpu_present_flip_abort);
+ if (!ret)
+ xf86DrvMsg(scrn->scrnIndex, X_ERROR, "present unflip failed\n");
+}
+
+static present_screen_info_rec amdgpu_present_screen_info = {
+ .version = 0,
+
+ .get_crtc = amdgpu_present_get_crtc,
+ .get_ust_msc = amdgpu_present_get_ust_msc,
+ .queue_vblank = amdgpu_present_queue_vblank,
+ .abort_vblank = amdgpu_present_abort_vblank,
+ .flush = amdgpu_present_flush,
+
+ .capabilities = PresentCapabilityNone,
+ .check_flip = amdgpu_present_check_flip,
+ .flip = amdgpu_present_flip,
+ .unflip = amdgpu_present_unflip,
+};
+
+static Bool
+amdgpu_present_has_async_flip(ScreenPtr screen)
+{
+#ifdef DRM_CAP_ASYNC_PAGE_FLIP
+ ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
+ AMDGPUInfoPtr info = AMDGPUPTR(scrn);
+ int ret;
+ uint64_t value;
+
+ ret = drmGetCap(info->dri2.drm_fd, DRM_CAP_ASYNC_PAGE_FLIP, &value);
+ if (ret == 0)
+ return value == 1;
+#endif
+ return FALSE;
+}
+
+Bool
+amdgpu_present_screen_init(ScreenPtr screen)
+{
+ if (amdgpu_present_has_async_flip(screen))
+ amdgpu_present_screen_info.capabilities |= PresentCapabilityAsync;
+
+ if (!present_screen_init(screen, &amdgpu_present_screen_info)) {
+ xf86DrvMsg(xf86ScreenToScrn(screen)->scrnIndex, X_WARNING,
+ "Present extension disabled because present_screen_init failed\n");
+ return FALSE;
+ }
+
+ xf86DrvMsg(xf86ScreenToScrn(screen)->scrnIndex, X_INFO,
+ "Present extension enabled\n");
+
+ return TRUE;
+}
+
+#else /* !HAVE_PRESENT_H */
+
+Bool
+amdgpu_present_screen_init(ScreenPtr screen)
+{
+ xf86DrvMsg(xf86ScreenToScrn(screen)->scrnIndex, X_INFO,
+ "Present extension disabled because present.h not available at "
+ "build time\n");
+
+ return FALSE;
+}
+
+#endif